// -----------------------------------------------
USceneCaptureComponent::USceneCaptureComponent(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer), ShowFlags(FEngineShowFlags(ESFIM_Game))
{
bCaptureEveryFrame = true;
MaxViewDistanceOverride = -1;
// Disable features that are not desired when capturing the scene
ShowFlags.MotionBlur = 0; // motion blur doesn't work correctly with scene captures.
ShowFlags.SeparateTranslucency = 0;
ShowFlags.HMDDistortion = 0;
}
// -----------------------------------------------
USceneCaptureComponent::USceneCaptureComponent(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer), ShowFlags(FEngineShowFlags(ESFIM_Game))
{
bCaptureEveryFrame = true;
MaxViewDistanceOverride = -1;
// Disable features that are not desired when capturing the scene
ShowFlags.SetMotionBlur(0); // motion blur doesn't work correctly with scene captures.
ShowFlags.SetSeparateTranslucency(0);
ShowFlags.SetHMDDistortion(0);
CaptureStereoPass = EStereoscopicPass::eSSP_FULL;
}
void UClassThumbnailRenderer::Draw(UObject* Object, int32 X, int32 Y, uint32 Width, uint32 Height, FRenderTarget* RenderTarget, FCanvas* Canvas)
{
UClass* Class = Cast<UClass>(Object);
if (Class != nullptr)
{
if ( ThumbnailScene == nullptr )
{
ThumbnailScene = new FClassThumbnailScene();
}
ThumbnailScene->SetClass(Class);
FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( RenderTarget, ThumbnailScene->GetScene(), FEngineShowFlags(ESFIM_Game) )
.SetWorldTimes(FApp::GetCurrentTime() - GStartTime, FApp::GetDeltaTime(), FApp::GetCurrentTime() - GStartTime));
ViewFamily.EngineShowFlags.DisableAdvancedFeatures();
ViewFamily.EngineShowFlags.MotionBlur = 0;
ThumbnailScene->GetView(&ViewFamily, X, Y, Width, Height);
GetRendererModule().BeginRenderingViewFamily(Canvas,&ViewFamily);
ThumbnailScene->SetClass(nullptr);
}
}
FSceneRenderer* FScene::CreateSceneRenderer( USceneCaptureComponent* SceneCaptureComponent, UTextureRenderTarget* TextureTarget, const FMatrix& ViewMatrix, const FVector& ViewLocation, float FOV, float MaxViewDistance, bool bCaptureSceneColour, FPostProcessSettings* PostProcessSettings, float PostProcessBlendWeight )
{
FIntPoint CaptureSize(TextureTarget->GetSurfaceWidth(), TextureTarget->GetSurfaceHeight());
FTextureRenderTargetResource* Resource = TextureTarget->GameThread_GetRenderTargetResource();
FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
Resource,
this,
FEngineShowFlags(ESFIM_Game))
.SetResolveScene(!bCaptureSceneColour));
// Disable features that are not desired when capturing the scene
ViewFamily.EngineShowFlags.MotionBlur = 0; // motion blur doesn't work correctly with scene captures.
ViewFamily.EngineShowFlags.SeparateTranslucency = 0;
ViewFamily.EngineShowFlags.HMDDistortion = 0;
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.SetViewRectangle(FIntRect(0, 0, CaptureSize.X, CaptureSize.Y));
ViewInitOptions.ViewFamily = &ViewFamily;
ViewInitOptions.ViewMatrix = ViewMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverrideFarClippingPlaneDistance = MaxViewDistance;
if (bCaptureSceneColour)
{
ViewFamily.EngineShowFlags.PostProcessing = 0;
ViewInitOptions.OverlayColor = FLinearColor::Black;
}
// Build projection matrix
{
float XAxisMultiplier;
float YAxisMultiplier;
if (CaptureSize.X > CaptureSize.Y)
{
// if the viewport is wider than it is tall
XAxisMultiplier = 1.0f;
YAxisMultiplier = CaptureSize.X / (float)CaptureSize.Y;
}
else
{
// if the viewport is taller than it is wide
XAxisMultiplier = CaptureSize.Y / (float)CaptureSize.X;
YAxisMultiplier = 1.0f;
}
ViewInitOptions.ProjectionMatrix = FReversedZPerspectiveMatrix (
FOV,
FOV,
XAxisMultiplier,
YAxisMultiplier,
GNearClippingPlane,
GNearClippingPlane
);
}
FSceneView* View = new FSceneView(ViewInitOptions);
View->bIsSceneCapture = true;
check(SceneCaptureComponent);
for (auto It = SceneCaptureComponent->HiddenComponents.CreateConstIterator(); It; ++It)
{
// If the primitive component was destroyed, the weak pointer will return NULL.
UPrimitiveComponent* PrimitiveComponent = It->Get();
if (PrimitiveComponent)
{
View->HiddenPrimitives.Add(PrimitiveComponent->ComponentId);
}
}
ViewFamily.Views.Add(View);
View->StartFinalPostprocessSettings(ViewLocation);
if (!bCaptureSceneColour)
{
View->OverridePostProcessSettings(*PostProcessSettings, PostProcessBlendWeight);
}
View->EndFinalPostprocessSettings();
return FSceneRenderer::CreateSceneRenderer(&ViewFamily, NULL);
}
void UStaticMeshThumbnailRenderer::Draw(UObject* Object, int32 X, int32 Y, uint32 Width, uint32 Height, FRenderTarget* RenderTarget, FCanvas* Canvas)
{
UStaticMesh* StaticMesh = Cast<UStaticMesh>(Object);
if (StaticMesh != nullptr && !StaticMesh->IsPendingKill())
{
if ( ThumbnailScene == nullptr )
{
ThumbnailScene = new FStaticMeshThumbnailScene();
}
ThumbnailScene->SetStaticMesh(StaticMesh);
ThumbnailScene->GetScene()->UpdateSpeedTreeWind(0.0);
FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( RenderTarget, ThumbnailScene->GetScene(), FEngineShowFlags(ESFIM_Game) )
.SetWorldTimes(FApp::GetCurrentTime() - GStartTime, FApp::GetDeltaTime(), FApp::GetCurrentTime() - GStartTime));
ViewFamily.EngineShowFlags.DisableAdvancedFeatures();
ViewFamily.EngineShowFlags.MotionBlur = 0;
ViewFamily.EngineShowFlags.LOD = 0;
ThumbnailScene->GetView(&ViewFamily, X, Y, Width, Height);
GetRendererModule().BeginRenderingViewFamily(Canvas,&ViewFamily);
ThumbnailScene->SetStaticMesh(nullptr);
}
}
void UWorldThumbnailRenderer::Draw(UObject* Object, int32 X, int32 Y, uint32 Width, uint32 Height, FRenderTarget* RenderTarget, FCanvas* Canvas)
{
UWorld* World = Cast<UWorld>(Object);
if (World != nullptr && World->Scene)
{
FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( RenderTarget, World->Scene, FEngineShowFlags(ESFIM_All0) )
.SetWorldTimes(FApp::GetCurrentTime() - GStartTime, FApp::GetDeltaTime(), FApp::GetCurrentTime() - GStartTime));
ViewFamily.EngineShowFlags.SetDiffuse(true);
ViewFamily.EngineShowFlags.SetSkeletalMeshes(true);
ViewFamily.EngineShowFlags.SetTranslucency(true);
ViewFamily.EngineShowFlags.SetBillboardSprites(true);
ViewFamily.EngineShowFlags.SetLOD(true);
ViewFamily.EngineShowFlags.SetMaterials(true);
ViewFamily.EngineShowFlags.SetStaticMeshes(true);
ViewFamily.EngineShowFlags.SetLandscape(true);
ViewFamily.EngineShowFlags.SetGame(true);
ViewFamily.EngineShowFlags.SetBSP(true);
ViewFamily.EngineShowFlags.SetRendering(true);
ViewFamily.EngineShowFlags.SetPaper2DSprites(true);
if ( !bUseUnlitScene )
{
ViewFamily.EngineShowFlags.SetSpecular(true);
ViewFamily.EngineShowFlags.SetLighting(true);
ViewFamily.EngineShowFlags.SetDirectLighting(true);
ViewFamily.EngineShowFlags.SetIndirectLightingCache(true);
ViewFamily.EngineShowFlags.SetDeferredLighting(true);
ViewFamily.EngineShowFlags.SetDirectionalLights(true);
ViewFamily.EngineShowFlags.SetGlobalIllumination(true);
ViewFamily.EngineShowFlags.SetPointLights(true);
ViewFamily.EngineShowFlags.SetSpotLights(true);
ViewFamily.EngineShowFlags.SetSkyLighting(true);
ViewFamily.EngineShowFlags.SetReflectionEnvironment(true);
}
GetView(World, &ViewFamily, X, Y, Width, Height);
if (ViewFamily.Views.Num() > 0)
{
GetRendererModule().BeginRenderingViewFamily(Canvas, &ViewFamily);
}
}
}
FCascadeEdPreviewViewportClient::FCascadeEdPreviewViewportClient(TWeakPtr<FCascade> InCascade, const TSharedRef<SCascadePreviewViewport>& InCascadeViewport)
: FEditorViewportClient(nullptr, nullptr, StaticCastSharedRef<SEditorViewport>(InCascadeViewport))
, CascadePtr(InCascade)
, CascadePreviewScene(FPreviewScene::ConstructionValues()
.SetLightRotation(FRotator(-45.f, 180.f, 0.f))
.SetSkyBrightness(0.25f)
.SetLightBrightness(1.f))
, VectorFieldHitproxyInfo(0)
, LightRotSpeed(0.22f)
{
PreviewScene = &CascadePreviewScene;
check(CascadePtr.IsValid() && EditorViewportWidget.IsValid());
UParticleSystem* ParticleSystem = CascadePtr.Pin()->GetParticleSystem();
UCascadeParticleSystemComponent* ParticleSystemComponent = CascadePtr.Pin()->GetParticleSystemComponent();
UVectorFieldComponent* LocalVectorFieldPreviewComponent = CascadePtr.Pin()->GetLocalVectorFieldComponent();
UCascadeOptions* EditorOptions = CascadePtr.Pin()->GetEditorOptions();
check(EditorOptions);
// Create ParticleSystemComponent to use for preview.
ParticleSystemComponent->CascadePreviewViewportPtr = this;
ParticleSystemComponent->CastShadow = true;
CascadePreviewScene.AddComponent(ParticleSystemComponent, FTransform::Identity);
ParticleSystemComponent->SetFlags(RF_Transactional);
// Create a component for previewing local vector fields.
LocalVectorFieldPreviewComponent->bPreviewVectorField = true;
LocalVectorFieldPreviewComponent->SetVisibility(false);
CascadePreviewScene.AddComponent(LocalVectorFieldPreviewComponent,FTransform::Identity);
// Use game defaults to hide emitter sprite etc., but we want to still show the Axis widget in the corner...
// todo: seems this cold be done cleaner
EngineShowFlags = FEngineShowFlags(ESFIM_Game);
EngineShowFlags.Game = 0;
EngineShowFlags.SetSnap(0);
SetViewMode(VMI_Lit);
EngineShowFlags.DisableAdvancedFeatures();
EngineShowFlags.SetCompositeEditorPrimitives(true);
EngineShowFlags.SeparateTranslucency = true;
OverrideNearClipPlane(1.0f);
SetViewLocation( FVector(-200.f, 0.f, 0.f) );
SetViewRotation( FRotator::ZeroRotator );
PreviewAngle = FRotator::ZeroRotator;
PreviewDistance = 0.f;
bCaptureScreenShot = false;
BackgroundColor = FColor::Black;
WidgetAxis = EAxisList::None;
WidgetMM = WMM_Translate;
bManipulatingVectorField = false;
DrawFlags = ParticleCounts | ParticleSystemCompleted;
bUsingOrbitCamera = true;
WireSphereRadius = 150.0f;
FColor GridColorAxis(0, 0, 80);
FColor GridColorMajor(0, 0, 72);
FColor GridColorMinor(0, 0, 64);
GridColorAxis = CascadePtr.Pin()->GetEditorOptions()->GridColor_Hi;
GridColorMajor = CascadePtr.Pin()->GetEditorOptions()->GridColor_Low;
GridColorMinor = CascadePtr.Pin()->GetEditorOptions()->GridColor_Low;
DrawHelper.bDrawGrid = CascadePtr.Pin()->GetEditorOptions()->bShowGrid;
DrawHelper.GridColorAxis = GridColorAxis;
DrawHelper.GridColorMajor = GridColorMajor;
DrawHelper.GridColorMinor = GridColorMinor;
DrawHelper.bDrawKillZ = false;
DrawHelper.bDrawWorldBox = false;
DrawHelper.bDrawPivot = false;
DrawHelper.PerspectiveGridSize = CascadePtr.Pin()->GetEditorOptions()->GridPerspectiveSize;
DrawHelper.DepthPriorityGroup = SDPG_World;
if (DrawHelper.bDrawGrid)
{
EngineShowFlags.SetGrid(true);
}
if (EditorOptions->FloorMesh == TEXT(""))
{
if (ParticleSystem != NULL)
{
EditorOptions->FloorMesh = ParticleSystem->FloorMesh;
EditorOptions->FloorScale = ParticleSystem->FloorScale;
EditorOptions->FloorScale3D = ParticleSystem->FloorScale3D;
}
else
{
EditorOptions->FloorMesh = FString::Printf(TEXT("/Engine/EditorMeshes/AnimTreeEd_PreviewFloor.AnimTreeEd_PreviewFloor"));
EditorOptions->FloorScale = 1.0f;
EditorOptions->FloorScale3D = FVector(1.0f, 1.0f, 1.0f);
}
EditorOptions->bShowFloor = false;
}
UStaticMesh* Mesh = NULL;
FloorComponent = NULL;
if (ParticleSystem)
{
Mesh = (UStaticMesh*)StaticLoadObject(UStaticMesh::StaticClass(),NULL,
*(ParticleSystem->FloorMesh),NULL,LOAD_None,NULL);
}
if ((Mesh == NULL) && (EditorOptions->FloorMesh != TEXT("")))
{
Mesh = (UStaticMesh*)StaticLoadObject(UStaticMesh::StaticClass(),NULL,
*(EditorOptions->FloorMesh),NULL,LOAD_None,NULL);
}
if (Mesh == NULL)
{
// Safety catch...
EditorOptions->FloorMesh = FString::Printf(TEXT("/Engine/EditorMeshes/AnimTreeEd_PreviewFloor.AnimTreeEd_PreviewFloor"));
Mesh = (UStaticMesh*)StaticLoadObject(UStaticMesh::StaticClass(),NULL,
*(EditorOptions->FloorMesh),NULL,LOAD_None,NULL);
}
if (Mesh)
{
FloorComponent = NewObject<UStaticMeshComponent>(GetTransientPackage(), TEXT("FloorComponent"));
check(FloorComponent);
FloorComponent->StaticMesh = Mesh;
FloorComponent->DepthPriorityGroup = SDPG_World;
// Hide it for now...
FloorComponent->SetVisibility(EditorOptions->bShowFloor);
if (ParticleSystem)
{
FloorComponent->RelativeLocation = ParticleSystem->FloorPosition;
FloorComponent->RelativeRotation = ParticleSystem->FloorRotation;
FloorComponent->SetRelativeScale3D(ParticleSystem->FloorScale3D);
}
else
{
FloorComponent->RelativeLocation = EditorOptions->FloorPosition;
FloorComponent->RelativeRotation = EditorOptions->FloorRotation;
FloorComponent->SetRelativeScale3D(EditorOptions->FloorScale3D);
}
FPhysScene* PhysScene = new FPhysScene();
CascadePreviewScene.GetWorld()->SetPhysicsScene(PhysScene);
CascadePreviewScene.AddComponent(FloorComponent,FTransform::Identity);
}
}
void ULevelThumbnailRenderer::Draw(UObject* Object, int32 X, int32 Y, uint32 Width, uint32 Height, FRenderTarget* RenderTarget, FCanvas* Canvas)
{
ULevel* Level = Cast<ULevel>(Object);
if (Level != nullptr)
{
FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( RenderTarget, Level->OwningWorld->Scene, FEngineShowFlags(ESFIM_Game) )
.SetWorldTimes(GCurrentTime - GStartTime,GDeltaTime,GCurrentTime - GStartTime) );
ViewFamily.EngineShowFlags.DisableAdvancedFeatures();
ViewFamily.EngineShowFlags.MotionBlur = 0;
ViewFamily.EngineShowFlags.Lighting = 1;
ViewFamily.EngineShowFlags.PostProcessing = 0;
GetView(Level, &ViewFamily, X, Y, Width, Height);
if (ViewFamily.Views.Num() > 0)
{
GetRendererModule().BeginRenderingViewFamily(Canvas, &ViewFamily);
}
}
}
void UMaterialFunctionThumbnailRenderer::Draw(UObject* Object, int32 X, int32 Y, uint32 Width, uint32 Height, FRenderTarget* RenderTarget, FCanvas* Canvas)
{
UMaterialFunction* MatFunc = Cast<UMaterialFunction>(Object);
if (MatFunc != nullptr)
{
if ( ThumbnailScene == nullptr )
{
ThumbnailScene = new FMaterialThumbnailScene();
}
UMaterial* PreviewMaterial = MatFunc->GetPreviewMaterial();
if( PreviewMaterial )
{
PreviewMaterial->ThumbnailInfo = MatFunc->ThumbnailInfo;
ThumbnailScene->SetMaterialInterface( PreviewMaterial );
FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( RenderTarget, ThumbnailScene->GetScene(), FEngineShowFlags(ESFIM_Game) )
.SetWorldTimes(FApp::GetCurrentTime() - GStartTime, FApp::GetDeltaTime(), FApp::GetCurrentTime() - GStartTime));
ViewFamily.EngineShowFlags.DisableAdvancedFeatures();
ViewFamily.EngineShowFlags.MotionBlur = 0;
ThumbnailScene->GetView(&ViewFamily, X, Y, Width, Height);
if (ViewFamily.Views.Num() > 0)
{
GetRendererModule().BeginRenderingViewFamily(Canvas,&ViewFamily);
}
ThumbnailScene->SetMaterialInterface(nullptr);
}
}
}
void AGameplayDebuggingHUDComponent::Render()
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
EngineShowFlags = Canvas && Canvas->SceneView && Canvas->SceneView->Family ? Canvas->SceneView->Family->EngineShowFlags : FEngineShowFlags(GIsEditor ? EShowFlagInitMode::ESFIM_Editor : EShowFlagInitMode::ESFIM_Game);
PrintAllData();
#endif
}
void AGameplayDebuggingReplicator::OnDebugAIDelegate(class UCanvas* Canvas, class APlayerController* PC)
{
#if WITH_EDITOR && !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (!GIsEditor)
{
return;
}
if (!LocalPlayerOwner || IsGlobalInWorld())
{
return;
}
UEditorEngine* EEngine = Cast<UEditorEngine>(GEngine);
if (GFrameNumber == LastDrawAtFrame || !EEngine || !EEngine->bIsSimulatingInEditor)
{
return;
}
if (!Canvas || !Canvas->SceneView || Canvas->SceneView->bIsGameView == false)
{
return;
}
LastDrawAtFrame = GFrameNumber;
FEngineShowFlags EngineShowFlags = Canvas && Canvas->SceneView && Canvas->SceneView->Family ? Canvas->SceneView->Family->EngineShowFlags : FEngineShowFlags(GIsEditor ? EShowFlagInitMode::ESFIM_Editor : EShowFlagInitMode::ESFIM_Game);
if (!EngineShowFlags.DebugAI)
{
return;
}
EnableDraw(true);
UWorld* World = GetWorld();
UGameplayDebuggingComponent* DebuggingComponent = GetDebugComponent();
if (World && DebuggingComponent && DebuggingComponent->GetOwnerRole() == ROLE_Authority)
{
UGameplayDebuggingControllerComponent* GDC = FindComponentByClass<UGameplayDebuggingControllerComponent>();
TArray<int32> OryginalReplicateViewDataCounters;
OryginalReplicateViewDataCounters = DebuggingComponent->ReplicateViewDataCounters;
for (uint32 Index = 0; Index < EAIDebugDrawDataView::MAX; ++Index)
{
DebuggingComponent->ReplicateViewDataCounters[Index] = GameplayDebuggerSettings(this).CheckFlag((EAIDebugDrawDataView::Type)Index) ? 1 : 0;
}
// looks like Simulate in UE4 Editor - let's find selected Pawn to debug
AActor* FullSelectedTarget = NULL;
for (FConstPawnIterator Iterator = World->GetPawnIterator(); Iterator; ++Iterator)
{
AActor* NewTarget = Cast<AActor>(*Iterator);
if (NewTarget->IsSelected() && !FullSelectedTarget)
{
FullSelectedTarget = NewTarget;
continue;
}
//We needs to collect data manually in Simulate
DebuggingComponent->SetActorToDebug(NewTarget);
DebuggingComponent->CollectDataToReplicate(NewTarget->IsSelected());
DrawDebugData(Canvas, PC);
}
const AActor* OldActor = LastSelectedActorToDebug;
ServerSetActorToDebug(FullSelectedTarget);
if (FullSelectedTarget)
{
DebuggingComponent->CollectDataToReplicate(true);
DebuggingComponent->SetEQSIndex(ActiveEQSIndex);
DrawDebugData(Canvas, PC);
}
if (GetSelectedActorToDebug() != OldActor)
{
DebuggingComponent->MarkRenderStateDirty();
}
DebuggingComponent->ReplicateViewDataCounters = OryginalReplicateViewDataCounters;
}
#endif
}
void AGameplayDebuggerReplicator::OnDebugAIDelegate(class UCanvas* Canvas, class APlayerController* PC)
{
#if WITH_EDITOR && ENABLED_GAMEPLAY_DEBUGGER
if (!GIsEditor)
{
return;
}
if (!LocalPlayerOwner)
{
return;
}
UEditorEngine* EEngine = Cast<UEditorEngine>(GEngine);
if (!EEngine || !EEngine->bIsSimulatingInEditor)
{
return;
}
if (!Canvas || !Canvas->SceneView || Canvas->SceneView->bIsGameView == false)
{
return;
}
FEngineShowFlags EngineShowFlags = Canvas && Canvas->SceneView && Canvas->SceneView->Family ? Canvas->SceneView->Family->EngineShowFlags : FEngineShowFlags(GIsEditor ? EShowFlagInitMode::ESFIM_Editor : EShowFlagInitMode::ESFIM_Game);
if (!EngineShowFlags.DebugAI)
{
return;
}
EnableDraw(true);
UWorld* World = GetWorld();
if (World && Role == ROLE_Authority)
{
if (IsActorTickEnabled() == false)
{
SetActorTickEnabled(true);
}
// looks like Simulate in UE4 Editor - let's find selected Pawn to debug
AActor* SelectedActor = nullptr;
for (FSelectionIterator It = EEngine->GetSelectedActorIterator(); It; ++It)
{
SelectedActor = Cast<APawn>(*It); //we only work with pawns for now
if (SelectedActor)
{
break;
}
}
if (LastSelectedActorToDebug != SelectedActor)
{
MarkComponentsRenderStateDirty();
}
ServerSetActorToDebug(SelectedActor);
DrawDebugData(Canvas, PC, true);
}
#endif
}
void RenderLandscapeMaterialForLightmass(const FLandscapeStaticLightingMesh* LandscapeMesh, FMaterialRenderProxy* MaterialProxy, const FRenderTarget* RenderTarget)
{
const ULandscapeComponent* LandscapeComponent = CastChecked<ULandscapeComponent>(LandscapeMesh->Component);
const int32 SubsectionSizeQuads = LandscapeComponent->SubsectionSizeQuads;
const int32 NumSubsections = LandscapeComponent->NumSubsections;
const int32 ComponentSizeQuads = LandscapeComponent->ComponentSizeQuads;
int32 PatchExpandCountX = 0;
int32 PatchExpandCountY = 0;
int32 DesiredSize = 1;
const float LightMapOffset = 0.0f;
const float LightMapRes = LandscapeComponent->StaticLightingResolution > 0.f ? LandscapeComponent->StaticLightingResolution : LandscapeComponent->GetLandscapeProxy()->StaticLightingResolution;
const int32 LightingLOD = LandscapeComponent->GetLandscapeProxy()->StaticLightingLOD;
const float LightMapRatio = ::GetTerrainExpandPatchCount(LightMapRes, PatchExpandCountX, PatchExpandCountY, ComponentSizeQuads, (NumSubsections * (SubsectionSizeQuads + 1)), DesiredSize, LightingLOD);
const FVector2D PatchExpandOffset = FVector2D((float)PatchExpandCountX / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)PatchExpandCountY / (ComponentSizeQuads + 2 * PatchExpandCountY)) * FVector2D(RenderTarget->GetSizeXY());
const FVector2D PatchExpandScale = FVector2D((float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountY));
TArray<FLightmassLandscapeVertex> Vertices;
TArray<uint16> Indices;
Vertices.Reserve(FMath::Square(NumSubsections) * 4);
Indices.Reserve(FMath::Square(NumSubsections) * 6);
const float fraction = 1.0f / NumSubsections;
const FVector2D PositionScale = FVector2D(RenderTarget->GetSizeXY()) * fraction * PatchExpandScale;
const float LayerScale = SubsectionSizeQuads;
const float WeightmapSubsection = LandscapeComponent->WeightmapSubsectionOffset;
const FVector2D WeightmapBias = FVector2D(LandscapeComponent->WeightmapScaleBias.Z, LandscapeComponent->WeightmapScaleBias.W);
const FVector2D WeightmapScale = FVector2D(LandscapeComponent->WeightmapScaleBias.X, LandscapeComponent->WeightmapScaleBias.Y) * SubsectionSizeQuads;
const int32 SubsectionX_Start = PatchExpandCountX > 0 ? -1 : 0;
const int32 SubsectionX_End = NumSubsections + (PatchExpandCountX > 0 ? 1 : 0);
const int32 SubsectionY_Start = PatchExpandCountY > 0 ? -1 : 0;
const int32 SubsectionY_End = NumSubsections + (PatchExpandCountY > 0 ? 1 : 0);
for (int32 SubsectionY = SubsectionY_Start; SubsectionY < SubsectionY_End; ++SubsectionY)
{
for (int32 SubsectionX = SubsectionX_Start; SubsectionX < SubsectionX_End; ++SubsectionX)
{
const FIntPoint UVSubsection = FIntPoint((SubsectionX >= 0 ? SubsectionX : 0),
(SubsectionY >= 0 ? SubsectionY : 0));
const FVector2D UVScale = FVector2D((SubsectionX >= 0 && SubsectionX < NumSubsections ? 1 : 0),
(SubsectionY >= 0 && SubsectionY < NumSubsections ? 1 : 0));
const FVector2D BasePosition = PatchExpandOffset + FVector2D(SubsectionX, SubsectionY) * PositionScale;
const FVector2D BaseLayerCoords = FVector2D(UVSubsection) * LayerScale;
const FVector2D BaseWeightmapCoords = WeightmapBias + FVector2D(UVSubsection) * WeightmapSubsection;
int32 Index = Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition /*FVector2D(0, 0) * PositionScale*/, 0), FVector(BaseLayerCoords /*FVector2D(0, 0) * UVScale * LayerScale*/, 0), BaseWeightmapCoords /*FVector2D(0, 0) * UVScale * WeightmapScale*/));
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 0) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 0) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 0) * UVScale * WeightmapScale )) == Index + 1);
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(0, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(0, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(0, 1) * UVScale * WeightmapScale )) == Index + 2);
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 1) * UVScale * WeightmapScale )) == Index + 3);
checkSlow(Index + 3 <= MAX_uint16);
Indices.Add(Index);
Indices.Add(Index + 3);
Indices.Add(Index + 1);
Indices.Add(Index);
Indices.Add(Index + 2);
Indices.Add(Index + 3);
}
}
FMeshBatch MeshElement;
MeshElement.DynamicVertexStride = sizeof(FLightmassLandscapeVertex);
MeshElement.UseDynamicData = true;
MeshElement.bDisableBackfaceCulling = true;
MeshElement.CastShadow = false;
MeshElement.bWireframe = false;
MeshElement.Type = PT_TriangleList;
MeshElement.DepthPriorityGroup = SDPG_Foreground;
MeshElement.bUseAsOccluder = false;
MeshElement.bSelectable = false;
MeshElement.DynamicVertexData = Vertices.GetData();
MeshElement.VertexFactory = &LightmassLandscapeVertexFactory;
MeshElement.MaterialRenderProxy = MaterialProxy;
FMeshBatchElement& BatchElement = MeshElement.Elements[0];
BatchElement.PrimitiveUniformBufferResource = &LightmassLandscapeUniformBuffer;
BatchElement.DynamicIndexData = Indices.GetData();
BatchElement.FirstIndex = 0;
BatchElement.NumPrimitives = Indices.Num() / 3;
BatchElement.MinVertexIndex = 0;
BatchElement.MaxVertexIndex = Vertices.Num() - 1;
BatchElement.DynamicIndexStride = sizeof(uint16);
FSceneViewFamily ViewFamily(FSceneViewFamily::ConstructionValues(
RenderTarget,
NULL,
FEngineShowFlags(ESFIM_Game))
.SetWorldTimes(0, 0, 0)
.SetGammaCorrection(RenderTarget->GetDisplayGamma()));
const FIntRect ViewRect(FIntPoint(0, 0), RenderTarget->GetSizeXY());
// make a temporary view
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = &ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = FVector::ZeroVector;
ViewInitOptions.ViewRotationMatrix = FMatrix::Identity;
ViewInitOptions.ProjectionMatrix = FCanvas::CalcBaseTransform2D(RenderTarget->GetSizeXY().X, RenderTarget->GetSizeXY().Y);
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverlayColor = FLinearColor::White;
FSceneView View(ViewInitOptions);
ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
CanvasFlushSetupCommand,
const FRenderTarget*, RenderTarget, RenderTarget,
{
//SCOPED_DRAW_EVENT(RHICmdList, CanvasFlush);
// Set the RHI render target.
::SetRenderTarget(RHICmdList, RenderTarget->GetRenderTargetTexture(), FTextureRHIRef());
// disable depth test & writes
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());
const FIntRect RTViewRect = FIntRect(0, 0, RenderTarget->GetRenderTargetTexture()->GetSizeX(), RenderTarget->GetRenderTargetTexture()->GetSizeY());
// set viewport to RT size
RHICmdList.SetViewport(RTViewRect.Min.X, RTViewRect.Min.Y, 0.0f, RTViewRect.Max.X, RTViewRect.Max.Y, 1.0f);
});