class TINYRENDERER_API FTinyRenderer
{
public:
	// コンストラクタ。FSceneViewFamilyを受け取る
	explicit FTinyRenderer(const FSceneViewFamily& InViewFamily);
	// StaticMesh およびその変換行列を設定する
	void SetStaticMeshData(UStaticMesh* InStaticMesh, const int32 InLODIndex, const FMatrix& InLocalToWorld,
	                       const TArray<UMaterialInterface*>& InOverrideMaterials);
	// 描画命令を発行する
	void Render(FRDGBuilder& GraphBuilder);

private:
	struct FTinySceneTextures
	{
		FRDGTextureRef SceneColorTexture;
		FRDGTextureRef SceneDepthTexture;
	};

	struct FMeshBatchesRequiredFeatures
	{
		bool bWorldPositionOffset = false;
	};

	FTinySceneTextures SetupSceneTextures(FRDGBuilder& GraphBuilder) const;
	void RenderBasePass(FRDGBuilder& GraphBuilder, const FTinySceneTextures& SceneTextures);

	bool CreateMeshBatch(TArray<FMeshBatch>& InMeshBatches,
	                     FMeshBatchesRequiredFeatures& RequiredFeatures) const;

	FGPUSceneResourceParameters SetupGPUSceneResourceParameters(FRDGBuilder& GraphBuilder,
	                                                            const FMeshBatchesRequiredFeatures& RequiredFeatures)
	const;

	void SetGPUSceneResourceParameters(const FGPUSceneResourceParameters& Parameters);

	ERHIFeatureLevel::Type FeatureLevel;
	const FSceneViewFamily& ViewFamily;
	FSceneUniformBuffer SceneUniforms;

	TWeakObjectPtr<UStaticMesh> StaticMesh;
	FMatrix LocalToWorld;
	int32 LODIndex;
	TArray<TWeakObjectPtr<UMaterialInterface>> OverrideMaterials;
};

void FTinyRenderer::Render(FRDGBuilder& GraphBuilder)
{
	// レンダリング対象の SceneTextures を作成
	const FTinySceneTextures SceneTextures = SetupSceneTextures(GraphBuilder);
	// BasePass をレンダリング
	RenderBasePass(GraphBuilder, SceneTextures);
}

FTinyRenderer::FTinySceneTextures FTinyRenderer::SetupSceneTextures(FRDGBuilder& GraphBuilder) const
{
	// 描画先の FRenderTarget を取得。これが SceneColor の出力先になる
	const FRenderTarget* RenderTarget = ViewFamily.RenderTarget;
	// RDG のリソース管理に外部の RenderTarget を登録し、RDG のテクスチャリソースを表す FRDGTextureRef を取得
	const FRDGTextureRef TinyRendererOutputRef = GraphBuilder.RegisterExternalTexture(
		CreateRenderTarget(RenderTarget->GetRenderTargetTexture(), TEXT("TinyRendererOutput")));

	// SceneDepth 用のテクスチャを作成。今回は外部から参照しないので、ここで作成して利用する。
	const FRDGTextureDesc Desc = FRDGTextureDesc::Create2D(RenderTarget->GetSizeXY(), PF_DepthStencil,
	                                                       FClearValueBinding::DepthFar,
	                                                       TexCreate_DepthStencilTargetable | TexCreate_ShaderResource);
	const FRDGTextureRef SceneDepth = GraphBuilder.CreateTexture(Desc, TEXT("SceneDepthZ"));

	return FTinySceneTextures{
		.SceneColorTexture = TinyRendererOutputRef,
		.SceneDepthTexture = SceneDepth
	};
}

void FTinyRenderer::RenderBasePass(FRDGBuilder& GraphBuilder, const FTinySceneTextures& SceneTextures)
{
	SCOPED_NAMED_EVENT(FTinyRenderer_RenderBasePass, FColor::Emerald);

	// レンダリング対象の StaticMesh を取得
	UStaticMesh* Mesh = StaticMesh.IsValid() ? StaticMesh.Get() : nullptr;
	if (!Mesh)
	{
		UE_LOG(LogTinyRenderer, Warning, TEXT("StaticMesh is not valid"));
		return;
	}

	// StaticMesh から MeshBatch を作成
	TArray<FMeshBatch> MeshBatches;
	FMeshBatchesRequiredFeatures RequiredFeatures;
	if (!CreateMeshBatch(MeshBatches, RequiredFeatures))
	{
		UE_LOG(LogTinyRenderer, Warning, TEXT("Failed to create mesh batch"));
		return;
	}

	// GPUScene のためのパラメータをセットアップ
	const FGPUSceneResourceParameters GPUSceneResourceParameters = SetupGPUSceneResourceParameters(GraphBuilder, RequiredFeatures);
	SetGPUSceneResourceParameters(GPUSceneResourceParameters);

	// レンダリング対象の View を取得	
	const FViewInfo* View = static_cast<const FViewInfo*>(ViewFamily.Views[0]);

	// レンダリングに利用する Shader のパラメータを構築
	FTinyRendererShaderParameters* PassParameters = GraphBuilder.AllocParameters<FTinyRendererShaderParameters>();
	PassParameters->View = View->ViewUniformBuffer;
	PassParameters->Scene = SceneUniforms.GetBuffer(GraphBuilder);
	// レンダリング結果の出力先を設定
	PassParameters->RenderTargets[0] = FRenderTargetBinding(SceneTextures.SceneColorTexture,
	                                                        ERenderTargetLoadAction::EClear);
	// DepthStencil の設定
	PassParameters->RenderTargets.DepthStencil = FDepthStencilBinding(SceneTextures.SceneDepthTexture,
	                                                                  ERenderTargetLoadAction::EClear,
	                                                                  ERenderTargetLoadAction::ELoad,
	                                                                  FExclusiveDepthStencil::DepthWrite_StencilWrite);

	// メッシュ描画用のパスを RDG に登録
	AddSimpleMeshPass(
		GraphBuilder, PassParameters, nullptr, *View, nullptr,
		RDG_EVENT_NAME("TinyRendererBasePass"),
		View->UnscaledViewRect, ERDGPassFlags::Raster,
		[View, MeshBatches](FDynamicPassMeshDrawListContext* DynamicMeshPassContext)
		{
			for (const FMeshBatch& MeshBatch : MeshBatches)
			{
				// マテリアルから ShaderBinding を取得するために、必要に応じて UniformExpression を更新
				MeshBatch.MaterialRenderProxy->UpdateUniformExpressionCacheIfNeeded(View->GetFeatureLevel());
				// MeshBatch を TinyRenderer 用の BasePassMeshProcessor に追加
				FTinyRendererBasePassMeshProcessor TinyRendererBasePassMeshProcessor(View, DynamicMeshPassContext);
				TinyRendererBasePassMeshProcessor.AddMeshBatch(MeshBatch, ~0ull, nullptr);
			}
		});
}

/**
 * @param OutMeshBatches 作成した MeshBatch を格納する配列
 * @param OutRequiredFeatures MeshBatch が描画時に必要とする機能
 * @return MeshBatch が作成できた場合は true、それ以外は false
 */
bool FTinyRenderer::CreateMeshBatch(TArray<FMeshBatch>& OutMeshBatches,
                                    FMeshBatchesRequiredFeatures& OutRequiredFeatures) const
{
	SCOPED_NAMED_EVENT_F(TEXT("FTinyRenderer::CreateMeshBatch - %s"), FColor::Emerald, *StaticMesh->GetName());

	// StaticMesh がコンパイル中の場合は MeshBatch を作成しない
	// Editor 用チェックであり、非 Editor ビルドでは定数化するので、最適化で消える
	if (StaticMesh->IsCompiling())
	{
		return false;
	}

	// StaticMesh から RenderData を取得。ここに StaticMesh のメッシュデータが格納されている
	FStaticMeshRenderData* RenderData = StaticMesh->GetRenderData();

	const int32 LODResourceIndex = FMath::Min(LODIndex, RenderData->LODResources.Num() - 1);
	if (LODResourceIndex < 0)
	{
		return false;
	}

	// 以下、LODResources から指定の LODIndex のメッシュデータを読み出し、MeshBatch を作成する
	const FStaticMeshSectionArray& Sections = RenderData->LODResources[LODResourceIndex].Sections;

	// セクションの数だけ MeshBatch を作成。一般的に、StaticMesh に割り当てられているマテリアルの数と対応している
	for (int32 SectionIndex = 0; SectionIndex < Sections.Num(); SectionIndex++)
	{
		const FStaticMeshSection& Section = Sections[SectionIndex];
		if (Section.NumTriangles == 0)
		{
			continue;
		}

		const FStaticMeshLODResources& LODResource = RenderData->LODResources[LODResourceIndex];

		// データを MeshBatch に格納していく
		FMeshBatch MeshBatch;
		MeshBatch.VertexFactory = &RenderData->LODVertexFactories[LODResourceIndex].VertexFactory;
		MeshBatch.Type = PT_TriangleList;

		// MeshBatch の Element に IndexBuffer などを格納。MeshBatch は複数の Element を持つことができるが、エンジンでも多くの場合は 1 つの Element しか使われていない
		FMeshBatchElement& BatchElement = MeshBatch.Elements[0];
		const FLocalVertexFactory* VertexFactory = static_cast<const FLocalVertexFactory*>(MeshBatch.VertexFactory);
		BatchElement.VertexFactoryUserData = VertexFactory->GetUniformBuffer();

		BatchElement.IndexBuffer = &LODResource.IndexBuffer;
		BatchElement.FirstIndex = Section.FirstIndex;
		BatchElement.NumPrimitives = Section.NumTriangles;
		BatchElement.MinVertexIndex = Section.MinVertexIndex;
		BatchElement.MaxVertexIndex = Section.MaxVertexIndex;
		BatchElement.PrimitiveIdMode = PrimID_DynamicPrimitiveShaderData;

		MeshBatch.LODIndex = LODResourceIndex;
		MeshBatch.SegmentIndex = SectionIndex;
		MeshBatch.CastShadow = false;

		const UMaterialInterface* OverrideMaterial = OverrideMaterials.IsValidIndex(Section.MaterialIndex)
			                                             ? OverrideMaterials[Section.MaterialIndex].Get()
			                                             : nullptr;

		const UMaterialInterface* MaterialInterface = OverrideMaterial
			                                              ? OverrideMaterial
			                                              : StaticMesh->GetMaterial(Section.MaterialIndex);

		// マテリアルを取得
		if (BatchElement.NumPrimitives > 0 && MaterialInterface)
		{
			const auto MaterialProxy = MaterialInterface->GetRenderProxy();
			// マテリアルのレンダースレッド表現である MaterialRenderProxy を MeshBatch に MaterialRenderProxy を格納
			MeshBatch.MaterialRenderProxy = MaterialProxy;
			OutMeshBatches.Add(MeshBatch);

			const FMaterialRelevance& MaterialRelevance = MaterialInterface->GetRelevance_Concurrent(FeatureLevel);
			// マテリアルが利用を要求しているレンダリング機能を RequiredFeatures に格納
			if (MaterialRelevance.bUsesWorldPositionOffset)
			{
				OutRequiredFeatures.bWorldPositionOffset = true;
			}
		}
	}

	if (OutMeshBatches.IsEmpty())
	{
		return false;
	}

	return true;
}

/**
 * @param GraphBuilder RDGBuilder
 * @param RequiredFeatures 対象の MeshBatch の描画時に必要とする機能
 * @return GPUScene のためのパラメータ
 */
FGPUSceneResourceParameters FTinyRenderer::SetupGPUSceneResourceParameters(FRDGBuilder& GraphBuilder,
                                                                           const FMeshBatchesRequiredFeatures& RequiredFeatures) const
{
	/* PrimitiveData として使うパラメータを構築 */
	const FPrimitiveUniformShaderParameters PrimitiveParams = FPrimitiveUniformShaderParametersBuilder{}
	                                                          .Defaults()
	                                                          .LocalToWorld(LocalToWorld)
	                                                          .ActorWorldPosition(LocalToWorld.GetOrigin())
	                                                          .EvaluateWorldPositionOffset(RequiredFeatures.bWorldPositionOffset)
	                                                          .Build();
	const FPrimitiveSceneShaderData PrimitiveSceneData(PrimitiveParams);

	FGPUSceneResourceParameters GPUSceneParameters;
	{
		/* Primitive Data のバッファを作成 */
		const FRDGBufferRef RDGPrimitiveSceneDataBuffer = CreateStructuredBuffer(GraphBuilder,
			TEXT("PrimitiveSceneDataBuffer"), TArray{PrimitiveSceneData});
		GPUSceneParameters.GPUScenePrimitiveSceneData = GraphBuilder.CreateSRV(RDGPrimitiveSceneDataBuffer);
		GPUSceneParameters.NumScenePrimitives = 1;
	}
	{
		FInstanceSceneShaderData InstanceSceneData{};
		InstanceSceneData.Build(0, /* PrimitiveId */
		                        0, /* RelativeId */
		                        0, /* InstanceFlags */
		                        INVALID_LAST_UPDATE_FRAME, /* LastUpdateFrame */
		                        0, /* CustomDataCount */
		                        0.0f, /* RandomID */
		                        FRenderTransform::Identity, /* LocalToPrimitive */
		                        PrimitiveParams.LocalToRelativeWorld); /* PrimitiveToWorld */

		/* Instance Data のバッファを作成 */
		TArray<FVector4f> InstanceSceneDataSOA;
		InstanceSceneDataSOA.AddZeroed(FInstanceSceneShaderData::GetDataStrideInFloat4s());
		for (uint32 ArrayIndex = 0; ArrayIndex < FInstanceSceneShaderData::GetDataStrideInFloat4s(); ArrayIndex++)
		{
			InstanceSceneDataSOA[ArrayIndex] = InstanceSceneData.Data[ArrayIndex];
		}
		const FRDGBufferRef RDGInstanceSceneDataBuffer = CreateStructuredBuffer(GraphBuilder,
			TEXT("InstanceSceneDataBuffer"), InstanceSceneDataSOA);
		GPUSceneParameters.GPUSceneInstanceSceneData = GraphBuilder.CreateSRV(RDGInstanceSceneDataBuffer);
		GPUSceneParameters.InstanceDataSOAStride = 1;
		GPUSceneParameters.NumInstances = 1;
	}
	{
		/* ダミーのバッファで不要なパラメータを埋める */
		const FRDGBufferRef DummyBufferVec4 = GSystemTextures.GetDefaultStructuredBuffer(
			GraphBuilder, sizeof(FVector4f));
		const FRDGBufferRef DummyBufferLight = GSystemTextures.GetDefaultStructuredBuffer(
			GraphBuilder, sizeof(FLightSceneData));

		GPUSceneParameters.GPUSceneInstancePayloadData = GraphBuilder.CreateSRV(DummyBufferVec4);
		GPUSceneParameters.GPUSceneLightmapData = GraphBuilder.CreateSRV(DummyBufferVec4);
		GPUSceneParameters.GPUSceneLightData = GraphBuilder.CreateSRV(DummyBufferLight);
	}

	/* たぶん NRVO が効くのでそのまま返しちゃいましょう */
	return GPUSceneParameters;
}

void FTinyRenderer::SetGPUSceneResourceParameters(const FGPUSceneResourceParameters& Parameters)
{
	SceneUniforms.Set(SceneUB::GPUScene, Parameters);
}

/* TinyRenderer の VS/PS 共通で利用する機能を定義 */
namespace TinyRendererShader
{
	/* シェーダーのコンパイル環境を変更 */
	static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters,
	                                         FShaderCompilerEnvironment& OutEnvironment)
	{
		/* GPUScene は利用するが、InstanceCulling は不要 */
		OutEnvironment.SetDefine(TEXT("USE_INSTANCE_CULLING_DATA"), 0);
		OutEnvironment.SetDefine(TEXT("USE_INSTANCE_CULLING"), 0);
	}

	/* 任意の ShaderPermutation に対してコンパイルを行うかどうかを判定 */
	static bool ShouldCompilePermutation(const FMeshMaterialShaderPermutationParameters& Parameters)
	{
		static FName NAME_LocalVertexFactory(TEXT("FLocalVertexFactory"));
		return (Parameters.MaterialParameters.MaterialDomain == MD_Surface) &&
			Parameters.VertexFactoryType == FindVertexFactoryType(NAME_LocalVertexFactory);
	}
}

/* TinyRenderer の頂点シェーダー C++ 定義 */
class FTinyRendererShaderVS : public FMeshMaterialShader
{
	DECLARE_SHADER_TYPE(FTinyRendererShaderVS, MeshMaterial);

	static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters,
	                                         FShaderCompilerEnvironment& OutEnvironment)
	{
		/* 親の環境定義を引き継ぎつつ、TinyRenderer 用の環境定義を追加 */
		FMeshMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
		TinyRendererShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
	}

	static bool ShouldCompilePermutation(const FMeshMaterialShaderPermutationParameters& Parameters)
	{
		return TinyRendererShader::ShouldCompilePermutation(Parameters);
	}
};

/* TinyRenderer のピクセルシェーダー C++ 定義 */
class FTinyRendererShaderPS : public FMeshMaterialShader
{
	DECLARE_SHADER_TYPE(FTinyRendererShaderPS, MeshMaterial);

	static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters,
	                                         FShaderCompilerEnvironment& OutEnvironment)
	{
		/* 親の環境定義を引き継ぎつつ、TinyRenderer 用の環境定義を追加 */
		FMeshMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
		TinyRendererShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);

		/* PixelShader 特有の環境定義を追加 */
		/* ライトベイクは行わないので、ライトマップ系機能は不要 */
		OutEnvironment.SetDefine(TEXT("NEEDS_LIGHTMAP_COORDINATE"), 0);
		/* 独自の出力を行うため、通常の SceneTexture は不要 */
		OutEnvironment.SetDefine(TEXT("SCENE_TEXTURES_DISABLED"), 1);
	}

	static bool ShouldCompilePermutation(const FMeshMaterialShaderPermutationParameters& Parameters)
	{
		return TinyRendererShader::ShouldCompilePermutation(Parameters);
	}
};

#include "/Engine/Generated/Material.ush"
#include "/Engine/Generated/VertexFactory.ush"

/* Vertex Shader から Pixel Shader へ受け渡すデータ */
struct FTinyRendererVSToPS
{
	float4 Position : SV_POSITION;
	float4 PixelPosition : POSITION8;
	FVertexFactoryInterpolantsVSToPS FactoryInterpolants;
};

/* Vertex Shader */
void MainVS(FVertexFactoryInput Input, out FTinyRendererVSToPS Output)
{
	ResolvedView = ResolveView();
	

	/* GPUScene から現在の処理対象のインスタンスの情報を取得 */
	FVertexFactoryIntermediates VFIntermediates = GetVertexFactoryIntermediates(Input);
	
	/* InstanceCullingData を Off にしていると、以下のフラグが常に false になってしまい、マテリアルが要求しても WPO が評価されない */
	/* このフラグが true でも、マテリアルが要求していない場合は WPO は評価されないので負荷の心配は不要 */
	VFIntermediates.bEvaluateWorldPositionOffset = true;
	
	const float4 WorldPositionExcludingWPO = VertexFactoryGetWorldPosition(Input, VFIntermediates);
	float4 WorldPos = WorldPositionExcludingWPO;
	
	const float3x3 TangentToLocal = VertexFactoryGetTangentToLocal(Input, VFIntermediates);

	/* マテリアルが生成した VertexShader 用のコードを呼び出し、結果を取得 */
	FMaterialVertexParameters VertexParameters = GetMaterialVertexParameters(Input, VFIntermediates, WorldPos.xyz, TangentToLocal);

	/* マテリアルが生成した WorldPositionOffset を適用 */
	WorldPos.xyz += GetMaterialWorldPositionOffset(VertexParameters);

	/* PixelShader に渡すデータを設定 */
	Output.Position = INVARIANT(mul(WorldPos, ResolvedView.TranslatedWorldToClip));
	Output.PixelPosition = WorldPos;
	Output.FactoryInterpolants = VertexFactoryGetInterpolantsVSToPS(Input, VFIntermediates, VertexParameters);
}

#define SUPPORT_CONTACT_SHADOWS 0

#include "/Engine/Private/BasePassCommon.ush"
#include "/Engine/Generated/Material.ush"
#include "/Engine/Private/ShadingModelsMaterial.ush"
#include "/Engine/Generated/VertexFactory.ush"
#include "/Engine/Private/DeferredLightingCommon.ush"

/* Pixel Shader */
void MainPS(
	in FTinyRendererVSToPS Interpolants,
	out float4 OutColor : SV_Target0
	OPTIONAL_IsFrontFace)
{
	ResolvedView = ResolveView();

	float3 WorldPosition = Interpolants.PixelPosition.xyz;

	/* マテリアルが生成した PixelShader 用のコードを呼び出し、結果を取得 */
	FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(
		Interpolants.FactoryInterpolants, Interpolants.Position);
	FPixelMaterialInputs PixelMaterialInputs;
	{
		/* スクリーン座標系の位置を取得 */
		float4 ScreenPosition = SvPositionToResolvedScreenPosition(Interpolants.Position);
		/* マテリアルから更に追加のパラメータを取得 */
		CalcMaterialParametersEx(MaterialParameters, PixelMaterialInputs, Interpolants.Position, ScreenPosition, bIsFrontFace,
		                         WorldPosition, WorldPosition);
	}

	/* マテリアルの各種出力を取得 */
	GetMaterialCoverageAndClipping(MaterialParameters, PixelMaterialInputs);
	half Opacity = GetMaterialOpacity(PixelMaterialInputs);
	half3 BaseColor = GetMaterialBaseColor(PixelMaterialInputs);
	half Metallic = GetMaterialMetallic(PixelMaterialInputs);
	half Specular = GetMaterialSpecular(PixelMaterialInputs);
	half Roughness = max(0.015625f, GetMaterialRoughness(PixelMaterialInputs));
	float Anisotropy = GetMaterialAnisotropy(PixelMaterialInputs);
	uint ShadingModelID = GetMaterialShadingModel(PixelMaterialInputs);

	/* GBuffer (という名前の構造体) にマテリアルの各種出力を設定。テクスチャリソースとしての GBuffer はここでは使われていないので注意 */
	FGBufferData GBuffer = (FGBufferData)0;
	GBuffer.Depth = MaterialParameters.ScreenPosition.w;

	SetGBufferForShadingModel(
		GBuffer,
		MaterialParameters,
		Opacity,
		BaseColor,
		Metallic,
		Specular,
		Roughness,
		Anisotropy,
		0.0f,
		0.0f,
		0.0f,
		ShadingModelID);

	/* スペキュラカラーやディフューズカラーを計算 */
	GBuffer.SpecularColor = ComputeF0(GBuffer.Specular, GBuffer.BaseColor, GBuffer.Metallic);
	GBuffer.DiffuseColor = GBuffer.BaseColor - GBuffer.BaseColor * GBuffer.Metallic;
	{
		GBuffer.DiffuseColor = GBuffer.DiffuseColor * ResolvedView.DiffuseOverrideParameter.w + ResolvedView.
			DiffuseOverrideParameter.xyz;
		GBuffer.SpecularColor = GBuffer.SpecularColor * ResolvedView.SpecularOverrideParameter.w + ResolvedView.
			SpecularOverrideParameter.xyz;
	}
	half3 DiffuseColor = GBuffer.DiffuseColor * 0.05f;

	half3 CameraVector = -MaterialParameters.CameraVector;
	float DirectionalLightShadow = 1.0f;

	/* Directional Light の設定 */
	FDeferredLightData LightData = (FDeferredLightData)0;
	{
		LightData.Color = float3(1, 1, 1);
		LightData.FalloffExponent = 0;
		LightData.Direction = float3(-0.5, -0.5, 0.5);
		LightData.bRadialLight = false;
		LightData.SpecularScale = 1.0f;
		LightData.ShadowedBits = 0;
		LightData.HairTransmittance = InitHairTransmittanceData();
	}
	half4 LightAttenuation = 1.0f;
	/* ライティングを計算 */
	FLightAccumulator DirectionalLighting = AccumulateDynamicLighting(WorldPosition, CameraVector, GBuffer,
	                                                          1, ShadingModelID, LightData,
	                                                          LightAttenuation, 0, uint2(0, 0),
	                                                          DirectionalLightShadow);
	half3 Color = DirectionalLighting.TotalLight;

	/* 最後にエミッシブカラーを加算 */
	half3 Emissive = GetMaterialEmissive(PixelMaterialInputs);
	Color += Emissive;

	/* 最終的な色を出力 */
	OutColor = float4(Color.rgb, 1.0f);
}

/* TinyRenderer の頂点シェーダーとピクセルシェーダーの実装 (.usf ファイル) と C++ 定義を関連付けて登録 */
IMPLEMENT_MATERIAL_SHADER_TYPE(, FTinyRendererShaderVS,
                                 TEXT("/StaticMeshRenderer/Private/TinyRendererShader.usf"),
                                 TEXT("MainVS"), SF_Vertex);
IMPLEMENT_MATERIAL_SHADER_TYPE(, FTinyRendererShaderPS,
                                 TEXT("/StaticMeshRenderer/Private/TinyRendererShader.usf"),
                                 TEXT("MainPS"), SF_Pixel);

/* TinyRenderer のシェーダーが利用するパラメータ構造体を定義 */
BEGIN_SHADER_PARAMETER_STRUCT(FTinyRendererShaderParameters,)
	SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
	SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FSceneUniformParameters, Scene)
	SHADER_PARAMETER_STRUCT_INCLUDE(FInstanceCullingDrawParams, InstanceCullingDrawParams)

	RENDER_TARGET_BINDING_SLOTS()
END_SHADER_PARAMETER_STRUCT()

// パラメータ構造体の確保を行う
FTinyRendererShaderParameters* PassParameters = GraphBuilder.AllocParameters<FTinyRendererShaderParameters>();
// パラメータ構造体にパラメータをセット
PassParameters->View = View->ViewUniformBuffer;
PassParameters->Scene = SceneUniforms.GetBuffer(GraphBuilder);
// RenderTargets は RENDER_TARGET_BINDING_SLOTS マクロで定義されたスロットを指している。
PassParameters->RenderTargets[0] = FRenderTargetBinding(SceneTextures.SceneColorTexture,
														ERenderTargetLoadAction::EClear);
PassParameters->RenderTargets.DepthStencil = FDepthStencilBinding(SceneTextures.SceneDepthTexture,
																	ERenderTargetLoadAction::EClear,
																	ERenderTargetLoadAction::ELoad,
																	FExclusiveDepthStencil::DepthWrite_StencilWrite);
// パラメータ構造体 (PassParameters) を RDG のパスに渡す。これだけで RDG がシェーダーへのパラメータのバインディングやライフタイム管理を行ってくれる
AddSimpleMeshPass(
	GraphBuilder, PassParameters, nullptr, *View, nullptr,
	RDG_EVENT_NAME("TinyRendererBasePass"),
	View->UnscaledViewRect, ERDGPassFlags::Raster,
	[View, MeshBatches](FDynamicPassMeshDrawListContext* DynamicMeshPassContext)
	{
		// 省略。パスの実装
	});

class FTinyRendererBasePassMeshProcessor : public FMeshPassProcessor
{
public:
	FTinyRendererBasePassMeshProcessor(const FSceneView* InView,
	                                   FMeshPassDrawListContext* InDrawListContext)
		: FMeshPassProcessor(nullptr, InView->GetFeatureLevel(), InView, InDrawListContext),
		  FeatureLevel(InView->GetFeatureLevel())
	{
		/* メッシュ描画時の RenderState を設定。パイプラインの挙動を制御することになる */
		PassDrawRenderState.SetBlendState(TStaticBlendState<>::GetRHI());
		PassDrawRenderState.SetDepthStencilAccess(FExclusiveDepthStencil::DepthWrite_StencilWrite);
		PassDrawRenderState.SetDepthStencilState(TStaticDepthStencilState<>::GetRHI());
	}

	/* この MeshPassProcessor を通じて指定された MeshBatch のメッシュ描画コマンドをコマンドリストに追加する処理 */
	bool TryAddMeshBatch(const FMeshBatch& MeshBatch,
	                     const uint64 BatchElementMask,
	                     const FPrimitiveSceneProxy* PrimitiveSceneProxy,
	                     const FMaterial& MaterialResource,
	                     const FMaterialRenderProxy& MaterialRenderProxy,
	                     const int32 StaticMeshId)
	{
		/* MeshBatch が利用する VertexFactory を取得 */
		const FVertexFactory* VertexFactory = MeshBatch.VertexFactory;
		TMeshProcessorShaders<FTinyRendererShaderVS, FTinyRendererShaderPS> TinyRenderPassShaders;

		/* MeshBatch が利用する ShaderType を登録 */
		FMaterialShaderTypes ShaderTypes;
		ShaderTypes.AddShaderType<FTinyRendererShaderVS>();
		ShaderTypes.AddShaderType<FTinyRendererShaderPS>();

		/* 上で登録した ShaderType と MeshBatch に割り当てられたマテリアルをもとに、実際に利用するシェーダーコードたちを取得 */
		FMaterialShaders Shaders;
		if (const FVertexFactoryType* VertexFactoryType = VertexFactory->GetType();
			!MaterialResource.TryGetShaders(ShaderTypes, VertexFactoryType, Shaders))
		{
			return false;
		}

		/* 頂点シェーダーとピクセルシェーダーを取得 */
		Shaders.TryGetVertexShader(TinyRenderPassShaders.VertexShader);
		Shaders.TryGetPixelShader(TinyRenderPassShaders.PixelShader);

		/* メッシュ描画時の RenderState を設定 */
		const FMeshPassProcessorRenderState DrawRenderState(PassDrawRenderState);

		FMeshMaterialShaderElementData ShaderElementData;
		ShaderElementData.InitializeMeshMaterialData(ViewIfDynamicMeshCommand, PrimitiveSceneProxy,
		                                             MeshBatch, StaticMeshId, true);

		const FMeshDrawCommandSortKey SortKey = CalculateMeshStaticSortKey(
			TinyRenderPassShaders.VertexShader, TinyRenderPassShaders.PixelShader);

		/* ラスタライザの FillMode と CullMode を設定 */
		const FMeshDrawingPolicyOverrideSettings OverrideSettings = ComputeMeshOverrideSettings(MeshBatch);
		const ERasterizerFillMode MeshFillMode = ComputeMeshFillMode(MaterialResource, OverrideSettings);
		const ERasterizerCullMode MeshCullMode = ComputeMeshCullMode(MaterialResource, OverrideSettings);

		/* MeshBatch に対応する描画コマンドを作成し、内部でコマンドリストに追加 */
		BuildMeshDrawCommands(
			MeshBatch,
			BatchElementMask,
			PrimitiveSceneProxy,
			MaterialRenderProxy,
			MaterialResource,
			DrawRenderState,
			TinyRenderPassShaders,
			MeshFillMode,
			MeshCullMode,
			SortKey,
			EMeshPassFeatures::Default,
			ShaderElementData);
		return true;
	}

	virtual void AddMeshBatch(const FMeshBatch& MeshBatch,
	                          const uint64 BatchElementMask,
	                          const FPrimitiveSceneProxy* PrimitiveSceneProxy,
	                          const int32 StaticMeshId = -1) override
	{
		const FMaterialRenderProxy* MaterialRenderProxy = MeshBatch.MaterialRenderProxy;

		while (MaterialRenderProxy)
		{
			if (const FMaterial* MaterialResource = MaterialRenderProxy->GetMaterialNoFallback(FeatureLevel);
				MaterialResource && TryAddMeshBatch(MeshBatch, BatchElementMask, PrimitiveSceneProxy,
				                                    *MaterialResource, *MaterialRenderProxy, StaticMeshId))
			{
				break;
			}
			/* 最初に取得したマテリアルが利用できなかったりコマンドの作成に失敗した場合は、Fallback のマテリアルを試す。
			   Fallback のマテリアルがない場合には nullptr が返るので、ループを抜ける */
			MaterialRenderProxy = MaterialRenderProxy->GetFallback(FeatureLevel);
		}
	}

private:
	FMeshPassProcessorRenderState PassDrawRenderState;
	ERHIFeatureLevel::Type FeatureLevel;
};

UCLASS(BlueprintType)
class UTinyRenderer : public UObject
{
	GENERATED_BODY()

public:
	UTinyRenderer();

	UFUNCTION(BlueprintCallable, Category = "Tiny Renderer",
		meta = (AutoCreateRefTerm = "BackgroundColor", WorldContext = "WorldContextObject"))
	static UTinyRenderer* CreateTinyRenderer(UObject* WorldContextObject,
	                                         UTextureRenderTarget2D* RenderTarget);

	UFUNCTION(BlueprintCallable, Category = "Static Mesh Renderer")
	void SetStaticMesh(UStaticMesh* InStaticMesh, const int32 LODIndex);

	UFUNCTION(BlueprintCallable, Category = "Static Mesh Renderer", meta = (AutoCreateRefTerm = "InTransform"))
	void SetTransform(const FTransform& InTransform);

	UFUNCTION(BlueprintCallable, Category = "Static Mesh Renderer")
	void SetOverrideMaterial(UMaterialInterface* InMaterial, int32 InMaterialIndex);

	UFUNCTION(BlueprintCallable, Category = "Static Mesh Renderer")
	UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamic(UMaterialInterface* SourceMaterial, const int32 MaterialIndex);

	UFUNCTION(BlueprintCallable, Category = "Static Mesh Renderer")
	void Render();

	UPROPERTY(BlueprintReadWrite, Category = "Static Mesh Renderer")
	FMinimalViewInfo ViewInfo;

private:
	// 省略
};

struct FMinimalViewInfo
{
	GENERATED_USTRUCT_BODY()

	/** Location */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
	FVector Location;

	/** Rotation */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
	FRotator Rotation;

	/** The horizontal field of view (in degrees) in perspective mode (ignored in orthographic mode). */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
	float FOV;

	/** The originally desired horizontal field of view before any adjustments to account for different aspect ratios */
	UPROPERTY(Transient)
	float DesiredFOV;

	/** The desired width (in world units) of the orthographic view (ignored in Perspective mode) */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
	float OrthoWidth;

	... 以下省略

void UTinyRenderer::Render()
{
	SCOPED_NAMED_EVENT(UTinyRenderer_Render, FColor::Green);

	if (!StaticMesh || !RenderTarget)
	{
		UE_LOG(LogTemp, Warning, TEXT("UStaticMeshRenderBP::RenderStaticMesh: Invalid parameters"));
		return;
	}

	/* RenderTaget から 描画リソースを取得 */
	const FTextureRenderTargetResource* RenderTargetResource = RenderTarget->GameThread_GetRenderTargetResource();


	/* ViewFamily オブジェクトの作成 */
	FSceneViewFamily::ConstructionValues
		ConstructionValues(RenderTargetResource, nullptr, FEngineShowFlags(ESFIM_Game));
	ConstructionValues.SetTime(FGameTime::GetTimeSinceAppStart());
	TUniquePtr<FSceneViewFamilyContext> ViewFamily = MakeUnique<FSceneViewFamilyContext>(ConstructionValues);

	/* ScreenPercentage の無効化 */
	ViewFamily->EngineShowFlags.ScreenPercentage = false;
	ViewFamily->SetScreenPercentageInterface(new FLegacyScreenPercentageDriver(*ViewFamily, 1.0f));

	/* MinimalViewInfo から ViewInitOptions を作成 */
	const FIntRect ViewRect(0, 0, RenderTarget->SizeX, RenderTarget->SizeY);
	FSceneViewInitOptions ViewInitOptions;
	ViewInitOptions.SetViewRectangle(ViewRect);
	ViewInitOptions.ViewFamily = ViewFamily.Get();
	ViewInitOptions.ViewOrigin = ViewInfo.Location;
	ViewInitOptions.ViewRotationMatrix = FMatrix(
		{0, 0, 1, 0},
		{1, 0, 0, 0},
		{0, 1, 0, 0},
		{0, 0, 0, 1});
	ViewInitOptions.FOV = ViewInfo.FOV;
	ViewInitOptions.DesiredFOV = ViewInfo.FOV;
	/* 投影行列を計算し、ViewInitOptions に設定 */
	FMinimalViewInfo::CalculateProjectionMatrixGivenViewRectangle(ViewInfo,
	                                                              AspectRatio_MaintainYFOV,
	                                                              ViewRect,
	                                                              ViewInitOptions);

	ENQUEUE_RENDER_COMMAND(FStaticMeshRenderCommand)(
		[this, ViewFamily = MoveTemp(ViewFamily), ViewInitOptions](
		FRHICommandListImmediate& RHICmdList) mutable
		{
			SCOPED_NAMED_EVENT(FStaticMeshRenderCommand_Render, FColor::Green);

			/* TinyRenderer オブジェクトの作成 */
			FTinyRenderer Renderer(*ViewFamily);
			/* RenderThread で ViewFamily の初期化を完了 */
			GetRendererModule().CreateAndInitSingleView(RHICmdList, ViewFamily.Get(), &ViewInitOptions);

			/* RDGBuilder の作成 */
			FRDGBuilder GraphBuilder(RHICmdList,
			                         RDG_EVENT_NAME("StaticMeshRender"),
			                         ERDGBuilderFlags::AllowParallelExecute);

			/* StaticMesh の設定 */
			Renderer.SetStaticMeshData(StaticMesh, LODIndex, Transform.ToMatrixWithScale(), OverrideMaterials);

			/* 作成したレンダラによる描画処理の登録 */
			Renderer.Render(GraphBuilder);

			/* RDGBuilder による RHI コマンドの発行と実行 */
			GraphBuilder.Execute();
		});
}