r.FastVRam.Distortion

r.FastVRam.Distortion

#Overview

name: r.FastVRam.Distortion

This variable is created as a Console Variable (cvar).

It is referenced in 62 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of r.FastVRam.Distortion is to control the texture creation flags for distortion-related textures in Unreal Engine’s rendering system. Specifically:

  1. It is used in the rendering subsystem of Unreal Engine, particularly in the distortion rendering pass.

  2. The variable is set using the FASTVRAM_CVAR macro, which likely creates a console variable that can be adjusted at runtime.

  3. Its value (1 in this case) determines whether certain textures related to distortion effects should be created with fast VRAM flags.

  4. The FFastVramConfig structure uses this variable to update the Distortion texture creation flags.

  5. These flags are then used when creating textures for the distortion pass, such as in the FDeferredShadingSceneRenderer::RenderDistortion function.

  6. The distortion pass is part of the post-processing pipeline and is responsible for rendering distortion effects in the scene.

  7. Developers should be aware that changing this variable can affect performance and memory usage, as it determines whether distortion textures are created in fast VRAM.

  8. Best practices would include:

    • Only enabling this if distortion effects are actually used in the scene
    • Monitoring performance and memory usage when adjusting this setting
    • Considering platform-specific implications, as fast VRAM might have different meanings on different hardware

  9. This variable interacts with other rendering systems, particularly the post-processing stack and the mesh pass processor for distortion.

  10. It’s part of a larger system of fast VRAM configuration options, alongside other effects like distance field shadows, volumetric fog, etc.

The associated variable “Distortion” is used in various parts of the engine, particularly in the rendering and post-processing systems. It’s used to represent distortion effects in materials, lens files, and rendering passes. The usage of this variable is consistent with its purpose of controlling and representing distortion-related rendering features throughout the engine.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:488

Scope: file

Source code excerpt:

FASTVRAM_CVAR(DistanceFieldIrradiance, 0); 
FASTVRAM_CVAR(DistanceFieldShadows, 1);
FASTVRAM_CVAR(Distortion, 1);
FASTVRAM_CVAR(ScreenSpaceShadowMask, 1);
FASTVRAM_CVAR(VolumetricFog, 1);
FASTVRAM_CVAR(SeparateTranslucency, 0); 
FASTVRAM_CVAR(SeparateTranslucencyModulate, 0);
FASTVRAM_CVAR(ScreenSpaceAO,0);
FASTVRAM_CVAR(SSR, 0);

#Associated Variable and Callsites

This variable is associated with another variable named Distortion. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Parameterization/PatchBasedMeshUVGenerator.cpp:278

Scope (from outer to inner):

file
function     static FUVAreaMetrics Compute_UV_Area_Metrics

Source code excerpt:

		Metrics.BoundsUV.Contain(UVTri[2]);

		double Distortion = FMath::Max(Area3D, Area2D) / FMath::Min(Area3D, Area2D);

		Distortion = FMath::Min(Distortion, ClampAreaDistortionMetric);
		if (SignedArea2D > 0)
		{
			Distortion = ClampAreaDistortionMetric;
		}

		SumAreaDistortion += Area3D * Distortion;
		SumDistortionsSqr += Area3D * Distortion * Distortion;
		MaxAreaDistortion = FMath::Max(MaxAreaDistortion, Distortion);

		FIndex3i TriEdges = Submesh.GetTriEdges(tid);
		for (int j = 0; j < 3; ++j)
		{
			if (Submesh.IsBoundaryEdge(TriEdges[j]))
			{

#Loc: <Workspace>/Engine/Plugins/Runtime/Harmonix/Source/HarmonixMetasound/Private/HarmonixMetasound/Nodes/DistortionNode.cpp:160

Scope (from outer to inner):

file
namespace    HarmonixMetasound
class        class FDistortionOperator final : public TExecutableOperator<FDistortionOperator>
function     FDistortionOperator

Source code excerpt:

			const FFilterSettings& InFilterSettings3
		)
			: Distortion(InSettings.GetSampleRate(), InSettings.GetNumFramesPerBlock())
			, AudioIn(InAudio)
			, InputBufferAlias(NumChannels, InSettings.GetNumFramesPerBlock(), EAudioBufferCleanupMode::DontDelete)
			, OutputBufferAlias(NumChannels, InSettings.GetNumFramesPerBlock(), EAudioBufferCleanupMode::DontDelete)
			, InputGain(InInputGain)
			, OutputGain(InOutputGain)
			, DryGain(InDryGain)

#Loc: <Workspace>/Engine/Plugins/Runtime/Harmonix/Source/HarmonixMetasound/Private/HarmonixMetasound/Nodes/DistortionNode.cpp:180

Scope (from outer to inner):

file
namespace    HarmonixMetasound
class        class FDistortionOperator final : public TExecutableOperator<FDistortionOperator>
function     FDistortionOperator

Source code excerpt:

			FDistortionSettingsV2 DistortionSettings;
			GetCurrentSettings(DistortionSettings);
			Distortion.Reset();
			Distortion.Setup(DistortionSettings, InSettings.GetSampleRate(), InSettings.GetNumFramesPerBlock(), true);
		}

		static const FVertexInterface& GetVertexInterface()
		{

#define METASOUND_GET_PARAM_NAME_WITH_INDEX_AND_METADATA_ADVANCED_DISPLAY(NAME, INDEX) METASOUND_GET_PARAM_NAME_WITH_INDEX(NAME, INDEX), FDataVertexMetadata { NAME##Tooltip, FText::Format(NAME##DisplayName, INDEX), true }

#Loc: <Workspace>/Engine/Plugins/Runtime/Harmonix/Source/HarmonixMetasound/Private/HarmonixMetasound/Nodes/DistortionNode.cpp:230

Scope (from outer to inner):

file
namespace    HarmonixMetasound
class        class FDistortionOperator final : public TExecutableOperator<FDistortionOperator>
function     static const FNodeClassMetadata& GetNodeInfo
lambda-function

Source code excerpt:

			{
				FNodeClassMetadata Info;
				Info.ClassName = { HarmonixNodeNamespace, TEXT("Distortion"), TEXT("") };
				Info.MajorVersion = 0;
				Info.MinorVersion = 1;
				Info.DisplayName = METASOUND_LOCTEXT("Distortion_DisplayName", "Distortion");
				Info.CategoryHierarchy = { MetasoundNodeCategories::Harmonix, NodeCategories::Dynamics };
				Info.Description = METASOUND_LOCTEXT("Distortion_Description", "Distortion audio effect.");
				Info.Author = PluginAuthor;

#Loc: <Workspace>/Engine/Plugins/Runtime/Harmonix/Source/HarmonixMetasound/Private/HarmonixMetasound/Nodes/DistortionNode.cpp:349

Scope (from outer to inner):

file
namespace    HarmonixMetasound
class        class FDistortionOperator final : public TExecutableOperator<FDistortionOperator>
function     void Reset

Source code excerpt:

			FDistortionSettingsV2 DistortionSettings;
			GetCurrentSettings(DistortionSettings);
			Distortion.Reset();
			Distortion.Setup(DistortionSettings, SampleRate, FramesPerBlock, true);
			AudioOut->Zero();
		}

		void Execute()
		{
			FDistortionSettingsV2 DistortionSettings;
			GetCurrentSettings(DistortionSettings);

			Distortion.SetInputGain(*InputGain);
			Distortion.SetOutputGain(*OutputGain);
			Distortion.SetWetGain(*WetGain);
			Distortion.SetDryGain(*DryGain);
			Distortion.SetDCOffset(*DCAdjust);
			Distortion.SetType(*DistortionType);
			Distortion.SetOversample(*Oversample, FramesPerBlock);

			for (int32 Index = 0; Index < NumFilters; ++Index)
			{
				FDistortionFilterSettings Settings;
				Settings.Filter.Type = *(FilterSettings[Index].FilterType);
				Settings.Filter.Freq = *(FilterSettings[Index].Freq);

#Loc: <Workspace>/Engine/Plugins/Runtime/Harmonix/Source/HarmonixMetasound/Private/HarmonixMetasound/Nodes/DistortionNode.cpp:378

Scope (from outer to inner):

file
namespace    HarmonixMetasound
class        class FDistortionOperator final : public TExecutableOperator<FDistortionOperator>
function     void Execute

Source code excerpt:

				Settings.Filter.IsEnabled = *(FilterSettings[Index].Enabled);

				Distortion.SetupFilter(Index, Settings);
			}

			const int32 NumSamples = AudioOut->Num();
			int32 SampleSliceSize = AudioRendering::kMicroSliceSize;
			InputBufferAlias.Alias(AudioIn->GetData(), NumSamples, NumChannels);
			OutputBufferAlias.Alias(AudioOut->GetData(), NumSamples, NumChannels);
			Distortion.Process(InputBufferAlias, OutputBufferAlias);
		}

	private:

		// INPUT
		FDistortionV2 Distortion;
		FAudioBufferReadRef AudioIn;
		TAudioBuffer<float> InputBufferAlias;
		TAudioBuffer<float> OutputBufferAlias;
		FFloatReadRef InputGain;
		FFloatReadRef OutputGain;
		FFloatReadRef DryGain;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/CameraCalibrationTimeSliderController.cpp:228

Scope (from outer to inner):

file
function     void FCameraCalibrationTimeSliderController::Tick

Source code excerpt:

	}
	else if (SelectedCategoryValue == ELensDataCategory::Zoom ||
			SelectedCategoryValue == ELensDataCategory::Distortion ||
			SelectedCategoryValue == ELensDataCategory::STMap ||
			SelectedCategoryValue == ELensDataCategory::ImageCenter ||
			SelectedCategoryValue == ELensDataCategory::NodalOffset)
	{
		if (SelectedFocus.IsSet())
		{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/LensInfoStep.cpp:219

Scope (from outer to inner):

file
function     void ULensInfoStep::SaveLensInformation

Source code excerpt:

		if (bHasModelChanged)
		{
			if (LensFile->HasSamples(ELensDataCategory::Distortion)
				|| LensFile->HasSamples(ELensDataCategory::ImageCenter)
				|| LensFile->HasSamples(ELensDataCategory::Zoom))
			{
				const FText Message = LOCTEXT("DataChangeDataLoss", "Lens model change detected. Distortion, ImageCenter and FocalLength data samples will be lost. Do you wish to continue?");
				if (FMessageDialog::Open(EAppMsgType::OkCancel, Message) != EAppReturnType::Ok)
				{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/LensInfoStep.cpp:233

Scope (from outer to inner):

file
function     void ULensInfoStep::SaveLensInformation

Source code excerpt:


			// Clear table when disruptive change is detected and user proceeds
			LensFile->ClearData(ELensDataCategory::Distortion);
			LensFile->ClearData(ELensDataCategory::ImageCenter);
			LensFile->ClearData(ELensDataCategory::Zoom);
		}

		// Cache the newly modified LensInfo as the most recently saved state
		CachedLensInfo = LensFile->LensInfo;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:165

Scope (from outer to inner):

file
lambda-function

Source code excerpt:

							case ELensDataCategory::Iris: return LOCTEXT("IrisCategory", "Encoder - Iris");
							case ELensDataCategory::Zoom: return LOCTEXT("ZoomCategory", "Focal Length");
							case ELensDataCategory::Distortion: return LOCTEXT("DistortionCategory", "Distortion Parameters");
							case ELensDataCategory::ImageCenter: return LOCTEXT("ImageCenterCategory", "Image Center");
							case ELensDataCategory::NodalOffset: return LOCTEXT("NodalOffsetCategory", "Nodal offset");
							case ELensDataCategory::STMap: return LOCTEXT("STMapCategory", "STMap");
							default: return LOCTEXT("InvalidCategory", "Invalid");
							}
						}))

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:296

Scope (from outer to inner):

file
function     TSharedRef<SWidget> SLensDataAddPointDialog::MakeTrackingDataWidget

Source code excerpt:

		}
		case ELensDataCategory::Zoom:
		case ELensDataCategory::Distortion:
		case ELensDataCategory::ImageCenter:
		case ELensDataCategory::NodalOffset:
		case ELensDataCategory::STMap:
		default:
		{
			TrackingWidget =

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:431

Scope (from outer to inner):

file
function     TSharedRef<SWidget> SLensDataAddPointDialog::MakeLensDataWidget

Source code excerpt:

			break;
		}
		case ELensDataCategory::Distortion:
		{
			DistortionInfoData->InitializeAs<FDistortionInfoContainer>();
			TSharedPtr<IStructureDetailsView> DistortionDataStructDetailsView = PropertyEditor.CreateStructureDetailView(DetailArgs, StructureViewArgs, TSharedPtr<FStructOnScope>());
			DistortionDataStructDetailsView->GetDetailsView()->RegisterInstancedCustomPropertyTypeLayout(FDistortionInfo::StaticStruct()->GetFName(),
				FOnGetPropertyTypeCustomizationInstance::CreateLambda([this]() { return MakeShared<FDistortionInfoCustomization>(LensFile->LensInfo.LensModel); })
			);

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:624

Scope (from outer to inner):

file
function     TSharedRef<SWidget> SLensDataAddPointDialog::MakeDataCategoryMenuWidget

Source code excerpt:

		AddMenuEntryFn(TEXT("Iris"), ELensDataCategory::Iris);
		AddMenuEntryFn(TEXT("Focal Length"), ELensDataCategory::Zoom);
		AddMenuEntryFn(TEXT("Distortion Parameters"), ELensDataCategory::Distortion);
		AddMenuEntryFn(TEXT("Image Center"), ELensDataCategory::ImageCenter);
		AddMenuEntryFn(TEXT("Nodal Offset"), ELensDataCategory::NodalOffset);
		AddMenuEntryFn(TEXT("STMap"), ELensDataCategory::STMap);
	}
	MenuBuilder.EndSection();

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:762

Scope (from outer to inner):

file
function     void SLensDataAddPointDialog::RefreshEvaluationData

Source code excerpt:

		}
		break;
		case ELensDataCategory::Distortion:
		case ELensDataCategory::ImageCenter:
		case ELensDataCategory::NodalOffset:
		case ELensDataCategory::STMap:
		default:
		{
			if (IsTrackingDataOverrided(0) == false)

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataAddPointDialog.cpp:835

Scope (from outer to inner):

file
function     void SLensDataAddPointDialog::AddDataToLensFile

Source code excerpt:

			break;
		}	
		case ELensDataCategory::Distortion:
		{
			FFocalLengthInfo FocalLengthValue = *FocalLengthData->Get();
			NormalizeValue(FocalLengthValue.FxFy);
			LensFile->AddDistortionPoint(TrackingInputData[0].Value, TrackingInputData[1].Value, DistortionInfoData->Get()->DistortionInfo, FocalLengthValue);
			break;
		}

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataListItem.cpp:182

Scope (from outer to inner):

file
function     void FZoomDataListItem::EditItem

Source code excerpt:

			break;
		}
		case ELensDataCategory::Distortion:
		{
			LensDataEditPointDialog::OpenDialog<FDistortionInfo>(LensFilePtr, GetFocus().GetValue(), Zoom, LensFilePtr->DistortionTable);
			break;
		}
		case ELensDataCategory::NodalOffset:
		{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataViewer.cpp:387

Scope (from outer to inner):

file
function     void SLensDataViewer::OnAddDataPointHandler

Source code excerpt:

	const FSimpleDelegate OnDataPointAdded = FSimpleDelegate::CreateSP(this, &SLensDataViewer::OnLensDataPointAdded);

	ELensDataCategory InitialCategory = ELensDataCategory::Distortion;
	if (TSharedPtr<FLensDataCategoryItem> CategoryItem = GetDataCategorySelection())
	{
		InitialCategory = CategoryItem->Category;
	}

	SLensDataAddPointDialog::OpenDialog(LensFile.Get(), InitialCategory, CachedFIZ, OnDataPointAdded);

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataViewer.cpp:443

Scope (from outer to inner):

file
function     void SLensDataViewer::RefreshDataCategoriesTree

Source code excerpt:

	if (LensFile->DataMode == ELensDataMode::Parameters)
	{
		TSharedPtr<FLensDataCategoryItem> DistortionEntry = MakeShared<FLensDataCategoryItem>(LensFile.Get(), nullptr, ELensDataCategory::Distortion, LensDataUtils::DistortionCategoryLabel);
		DataCategories.Add(DistortionEntry);

		TArray<FText> Parameters;
		if (LensFile->LensInfo.LensModel)
		{
			Parameters = LensFile->LensInfo.LensModel.GetDefaultObject()->GetParameterDisplayNames();

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataViewer.cpp:455

Scope (from outer to inner):

file
function     void SLensDataViewer::RefreshDataCategoriesTree

Source code excerpt:

		{
			const FText& Parameter = Parameters[Index];
			DistortionEntry->Children.Add(MakeShared<FDistortionParametersCategoryItem>(LensFile.Get(), DistortionEntry, ELensDataCategory::Distortion, *Parameter.ToString(), Index));
		}
	}
	else
	{
		DataCategories.Add(MakeShared<FLensDataCategoryItem>(LensFile.Get(), nullptr, ELensDataCategory::STMap, LensDataUtils::MapsCategoryLabel));
	}

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataViewer.cpp:515

Scope (from outer to inner):

file
function     void SLensDataViewer::RefreshDataEntriesTree

Source code excerpt:

				break;
			}
			case ELensDataCategory::Distortion:
			{
				const TConstArrayView<FDistortionFocusPoint> FocusPoints = LensFile->DistortionTable.GetFocusPoints();
				LensDataUtils::MakeFocusEntries(LensFile.Get(), CategoryItem->Category, CategoryItem->GetParameterIndex(), FocusPoints, DataEntries, DataRemovedCallback);
				break;
			}
			case ELensDataCategory::ImageCenter:

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibration/Source/CameraCalibrationEditor/Private/AssetEditor/SLensDataViewer.cpp:583

Scope (from outer to inner):

file
function     void SLensDataViewer::RefreshCurve

Source code excerpt:

				break;
			}
			case ELensDataCategory::Distortion:
			{
				if (CurrentDataItem)
				{
					const TOptional<float> Focus = CurrentDataItem->GetFocus();
					if(Focus.IsSet())
					{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/LensFile.cpp:1090

Scope (from outer to inner):

file
function     void ULensFile::RemoveFocusPoint

Source code excerpt:

	switch(InDataCategory)
	{
		case ELensDataCategory::Distortion:
		{
			DistortionTable.RemoveFocusPoint(InFocus);
			break;
		}
		case ELensDataCategory::ImageCenter:
		{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/LensFile.cpp:1134

Scope (from outer to inner):

file
function     void ULensFile::RemoveZoomPoint

Source code excerpt:

	switch(InDataCategory)
	{
		case ELensDataCategory::Distortion:
		{
			DistortionTable.RemoveZoomPoint(InFocus, InZoom);
			break;
		}
		case ELensDataCategory::ImageCenter:
		{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/LensFile.cpp:1180

Scope (from outer to inner):

file
function     void ULensFile::ClearData

Source code excerpt:

	switch(InDataCategory)
	{
		case ELensDataCategory::Distortion:
		{
			LensDataTableUtils::EmptyTable(DistortionTable);
			break;
		}
		case ELensDataCategory::ImageCenter:
		{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/LensFile.cpp:1230

Scope (from outer to inner):

file
function     int32 ULensFile::GetTotalPointNum

Source code excerpt:

	switch(InDataCategory)
	{
		case ELensDataCategory::Distortion:
		{
			return DistortionTable.GetTotalPointNum();
		}
		case ELensDataCategory::ImageCenter:
		{
			return ImageCenterTable.GetTotalPointNum();

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/LensFile.cpp:1269

Scope (from outer to inner):

file
function     const FBaseLensTable* ULensFile::GetDataTable

Source code excerpt:

	switch(InDataCategory)
	{
		case ELensDataCategory::Distortion:
		{
			return &DistortionTable;
		}
		case ELensDataCategory::ImageCenter:
		{
			return &ImageCenterTable;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tables/BaseLensTable.cpp:8

Scope (from outer to inner):

file
function     FName FBaseLensTable::GetFriendlyPointName

Source code excerpt:

	{
		case ELensDataCategory::Zoom: return TEXT("Focal Length");
		case ELensDataCategory::Distortion: return TEXT("Distortion Parameters");
		case ELensDataCategory::ImageCenter: return TEXT("Image Center");
		case ELensDataCategory::STMap: return TEXT("ST Map");
		case ELensDataCategory::NodalOffset: return TEXT("Nodal Offset");
	}

	return TEXT("");

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tables/FocalLengthTable.cpp:144

Scope (from outer to inner):

file
function     TMap<ELensDataCategory, FLinkPointMetadata> FFocalLengthTable::GetLinkedCategories

Source code excerpt:

	static TMap<ELensDataCategory, FLinkPointMetadata> LinkedToCategories =
	{
		{ELensDataCategory::Distortion, {true}},
		{ELensDataCategory::ImageCenter, {true}},
		{ELensDataCategory::STMap, {true}},
		{ELensDataCategory::NodalOffset, {false}},
	};
	return LinkedToCategories;
}

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tables/ImageCenterTable.cpp:184

Scope (from outer to inner):

file
function     TMap<ELensDataCategory, FLinkPointMetadata> FImageCenterTable::GetLinkedCategories

Source code excerpt:

	static TMap<ELensDataCategory, FLinkPointMetadata> LinkedToCategories =
	{
		{ELensDataCategory::Distortion, {true}},
		{ELensDataCategory::Zoom, {true}},
		{ELensDataCategory::STMap, {true}},
		{ELensDataCategory::NodalOffset, {false}},
	};
	return LinkedToCategories;
}

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tables/NodalOffsetTable.cpp:167

Scope (from outer to inner):

file
function     TMap<ELensDataCategory, FLinkPointMetadata> FNodalOffsetTable::GetLinkedCategories

Source code excerpt:

	static TMap<ELensDataCategory, FLinkPointMetadata> LinkedToCategories =
	{
		{ELensDataCategory::Distortion, {false}},
		{ELensDataCategory::Zoom, {false}},
		{ELensDataCategory::STMap, {false}},
		{ELensDataCategory::ImageCenter, {false}},
	};
	return LinkedToCategories;
}

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tests/TestDistortionMapping.cpp:106

Scope (from outer to inner):

file
namespace    CameraCalibrationTestUtil
function     void TestDistortionParameterCurveBlending
function     FLensData

Source code excerpt:

				: Focus(InFocus)
				, Zoom(InZoom)
				, Distortion(InDistortionInfo)
				, ImageCenter(InImageCenter)
				, FocalLength(InFocalLength)
			{}
			
			float Focus;
			float Zoom;
			FDistortionInfo Distortion;
			FImageCenterInfo ImageCenter;
			FFocalLengthInfo FocalLength;
		};

		constexpr int32 InputCount = 4;
		FLensData InputData[InputCount] =

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tests/TestDistortionMapping.cpp:131

Scope (from outer to inner):

file
namespace    CameraCalibrationTestUtil
function     void TestDistortionParameterCurveBlending

Source code excerpt:

			//straight tests
			const FLensData& Input = InputData[InputIndex];
			LensFile->AddDistortionPoint(Input.Focus, Input.Zoom, Input.Distortion, Input.FocalLength);
			LensFile->AddImageCenterPoint(Input.Focus, Input.Zoom, Input.ImageCenter);
		}

		const FLensData& Input0 = InputData[0];
		const FLensData& Input1 = InputData[1];
		const FLensData& Input2 = InputData[2];

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tests/TestDistortionMapping.cpp:141

Scope (from outer to inner):

file
namespace    CameraCalibrationTestUtil
function     void TestDistortionParameterCurveBlending

Source code excerpt:

		FLensData EvaluatedData;
		LensFile->EvaluateImageCenterParameters(Input0.Focus, Input0.Zoom, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input0.Focus, Input0.Zoom, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input0.Focus, Input0.Zoom, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input0.Focus, Input0.Zoom, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y});
		TestEvaluationResult<float>(Test, Input0.Distortion.Parameters, EvaluatedData.Distortion.Parameters);
		TestEvaluationResult<float>(Test, Input0.Distortion.Parameters, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y});

		LensFile->EvaluateImageCenterParameters(Input1.Focus, Input1.Zoom, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input1.Focus, Input1.Zoom, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input1.Focus, Input1.Zoom, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input1.Focus, Input1.Zoom, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y}, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y}, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y});
		TestEvaluationResult<float>(Test, Input1.Distortion.Parameters, EvaluatedData.Distortion.Parameters);
		TestEvaluationResult<float>(Test, Input1.Distortion.Parameters, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y});

		
		LensFile->EvaluateImageCenterParameters(Input2.Focus, Input2.Zoom, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input2.Focus, Input2.Zoom, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input2.Focus, Input2.Zoom, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input2.Focus, Input2.Zoom, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y}, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y}, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y});
		TestEvaluationResult<float>(Test, Input2.Distortion.Parameters, EvaluatedData.Distortion.Parameters);
		TestEvaluationResult<float>(Test, Input2.Distortion.Parameters, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y});

		LensFile->EvaluateImageCenterParameters(Input3.Focus, Input3.Zoom, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input3.Focus, Input3.Zoom, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input3.Focus, Input3.Zoom, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input3.Focus, Input3.Zoom, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y}, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y}, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y});
		TestEvaluationResult<float>(Test, Input3.Distortion.Parameters, EvaluatedData.Distortion.Parameters);
		TestEvaluationResult<float>(Test, Input3.Distortion.Parameters, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters);
		TestEvaluationResult<FVector2D::FReal>(Test, {Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y});
		TestEvaluationResult<FVector2D::FReal>(Test, {Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y}, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y});

		//Sin
		constexpr FVector2D::FReal BlendFactor = 0.25f;	
		LensFile->EvaluateImageCenterParameters(Input0.Focus, 0.25f, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input0.Focus, 0.25f, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input0.Focus, 0.25f, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input0.Focus, 0.25f, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y}, BlendFactor, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y});
		TestSingleCurveEvaluationResult<float>(Test, EvaluatedData.Distortion.Parameters, BlendFactor, Input0.Distortion.Parameters, Input1.Distortion.Parameters);
		TestSingleCurveEvaluationResult<float>(Test, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters, BlendFactor, Input0.Distortion.Parameters, Input1.Distortion.Parameters);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y}, BlendFactor, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y});

		
		LensFile->EvaluateImageCenterParameters(Input2.Focus, 0.25f, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(Input2.Focus, 0.25f, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(Input2.Focus, 0.25f, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(Input2.Focus, 0.25f, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y}, {Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y}, BlendFactor, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y}, {Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y});
		TestSingleCurveEvaluationResult<float>(Test, EvaluatedData.Distortion.Parameters, BlendFactor, Input2.Distortion.Parameters, Input3.Distortion.Parameters);
		TestSingleCurveEvaluationResult<float>(Test, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters, BlendFactor, Input2.Distortion.Parameters, Input3.Distortion.Parameters);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y}, {Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y}, BlendFactor, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y}, {Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y});

		LensFile->EvaluateImageCenterParameters(0.25f, Input0.Zoom, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(0.25f, Input0.Zoom, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(0.25f, Input0.Zoom, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(0.25f, Input0.Zoom, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y}, BlendFactor, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y});
		TestSingleCurveEvaluationResult<float>(Test, EvaluatedData.Distortion.Parameters, BlendFactor, Input0.Distortion.Parameters, Input2.Distortion.Parameters);
		TestSingleCurveEvaluationResult<float>(Test, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters, BlendFactor, Input0.Distortion.Parameters, Input2.Distortion.Parameters);
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y}, BlendFactor, {Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y}, {Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y});
		TestSingleCurveEvaluationResult<FVector2D::FReal>(Test, {ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y}, BlendFactor, {Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y}, {Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y});
		
		LensFile->EvaluateImageCenterParameters(0.25f, 0.25f, EvaluatedData.ImageCenter);
		LensFile->EvaluateDistortionParameters(0.25f, 0.25f, EvaluatedData.Distortion);
		LensFile->EvaluateFocalLength(0.25f, 0.25f, EvaluatedData.FocalLength);
		LensFile->EvaluateDistortionData(0.25f, 0.25f, LensFile->LensInfo.SensorDimensions, ProducedLensDistortionHandler);
		TestDualCurveEvaluationResult<FVector2D::FReal>(Test, { EvaluatedData.ImageCenter.PrincipalPoint.X, EvaluatedData.ImageCenter.PrincipalPoint.Y }, BlendFactor, { Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y }, { Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y }, { Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y }, { Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y });
		TestDualCurveEvaluationResult<FVector2D::FReal>(Test, { EvaluatedData.FocalLength.FxFy.X, EvaluatedData.FocalLength.FxFy.Y }, BlendFactor, { Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y }, { Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y }, { Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y }, { Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y });
		TestDualCurveEvaluationResult<float>(Test, EvaluatedData.Distortion.Parameters, BlendFactor, Input0.Distortion.Parameters, Input1.Distortion.Parameters, Input2.Distortion.Parameters, Input3.Distortion.Parameters);
		TestDualCurveEvaluationResult<float>(Test, ProducedLensDistortionHandler->GetCurrentDistortionState().DistortionInfo.Parameters, BlendFactor, Input0.Distortion.Parameters, Input1.Distortion.Parameters, Input2.Distortion.Parameters, Input3.Distortion.Parameters);
		TestDualCurveEvaluationResult<FVector2D::FReal>(Test, { ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.X, ProducedLensDistortionHandler->GetCurrentDistortionState().ImageCenter.PrincipalPoint.Y }, BlendFactor, { Input0.ImageCenter.PrincipalPoint.X, Input0.ImageCenter.PrincipalPoint.Y }, { Input1.ImageCenter.PrincipalPoint.X, Input1.ImageCenter.PrincipalPoint.Y }, { Input2.ImageCenter.PrincipalPoint.X, Input2.ImageCenter.PrincipalPoint.Y }, { Input3.ImageCenter.PrincipalPoint.X, Input3.ImageCenter.PrincipalPoint.Y });
		TestDualCurveEvaluationResult<FVector2D::FReal>(Test, { ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.X, ProducedLensDistortionHandler->GetCurrentDistortionState().FocalLengthInfo.FxFy.Y }, BlendFactor, { Input0.FocalLength.FxFy.X, Input0.FocalLength.FxFy.Y }, { Input1.FocalLength.FxFy.X, Input1.FocalLength.FxFy.Y }, { Input2.FocalLength.FxFy.X, Input2.FocalLength.FxFy.Y }, { Input3.FocalLength.FxFy.X, Input3.FocalLength.FxFy.Y });
	}

	void TestLensFileAddPoints(FAutomationTestBase& Test)
	{

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tests/TestDistortionMapping.cpp:386

Scope (from outer to inner):

file
namespace    CameraCalibrationTestUtil
function     void TestLensFileRemovePoints

Source code excerpt:

			const float ZoomValue = 0.191f;
			LensFile->AddDistortionPoint(FocusValue, ZoomValue, DistortionPoint, FocalLengthInfo);
			LensFile->RemoveZoomPoint(ELensDataCategory::Distortion, FocusValue, ZoomValue);
			const int32 DistortionPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Distortion);
			int32 FocalLengthPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Zoom);
			Test.TestEqual(TEXT("Num Distortion Points"), DistortionPointsNum, 0);
			Test.TestEqual(TEXT("Num FocalLength Points"), FocalLengthPointsNum, 1);
			LensFile->RemoveZoomPoint(ELensDataCategory::Zoom, FocusValue, ZoomValue);
			FocalLengthPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Zoom);
			Test.TestEqual(TEXT("Num FocalLength Points"), FocalLengthPointsNum, 0);

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Private/Tests/TestDistortionMapping.cpp:406

Scope (from outer to inner):

file
namespace    CameraCalibrationTestUtil
function     void TestLensFileRemovePoints

Source code excerpt:

			int32 FocalLengthPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Zoom);
			Test.TestEqual(TEXT("Num FocalLength Points"), FocalLengthPointsNum, 1);
			LensFile->RemoveZoomPoint(ELensDataCategory::Distortion, FocusValue, ZoomValue);
			const int32 DistortionPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Distortion);
			FocalLengthPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Zoom);
			Test.TestEqual(TEXT("Num Distortion Points"), DistortionPointsNum, 0);
			Test.TestEqual(TEXT("Num FocalLength Points"), FocalLengthPointsNum, 1);
			LensFile->RemoveZoomPoint(ELensDataCategory::Zoom, FocusValue, ZoomValue);
			FocalLengthPointsNum = LensFile->GetTotalPointNum(ELensDataCategory::Zoom);
			Test.TestEqual(TEXT("Num FocalLength Points"), FocalLengthPointsNum, 0);

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Public/CameraCalibrationSettings.h:146

Scope (from outer to inner):

file
function     FColor GetColorForCategory

Source code excerpt:

		case ELensDataCategory::Zoom:
			return Zoom;
		case ELensDataCategory::Distortion:
			return Distortion;
		case ELensDataCategory::ImageCenter:
			return ImageCenter;
		case ELensDataCategory::STMap:
			return STMap;
		case ELensDataCategory::NodalOffset:
			return NodalOffset;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Public/CameraCalibrationSettings.h:170

Scope: file

Source code excerpt:


	UPROPERTY(EditAnywhere, Category = "Settings")
	FColor Distortion = FColor::Cyan;

	UPROPERTY(EditAnywhere, Category = "Settings")
	FColor ImageCenter = FColor::Yellow;

	UPROPERTY(EditAnywhere, Category = "Settings")
	FColor STMap = FColor::Orange;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Public/LensFile.h:47

Scope: file

Source code excerpt:

	Iris,
	Zoom,
	Distortion,
	ImageCenter,
	STMap,
	NodalOffset,
};

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Public/LensFile.h:401

Scope: file

Source code excerpt:

		/** The filmback used when evaluating the distortion data */
		FVector2D Filmback;
	} Distortion;

	/** Information about the nodal offset evaluation */
	struct
	{
		/** True if the evaluated nodal offset was applied to the camera */
		bool bWasApplied;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/CameraCalibrationCore/Source/CameraCalibrationCore/Public/LensFile.h:419

Scope (from outer to inner):

file
function     void Invalidate

Source code excerpt:

		Input.Zoom = 0.0f;

		Distortion.Filmback = FVector2D(0);

		Camera.UniqueId = INDEX_NONE;
		Distortion.bWasEvaluated = false;
		NodalOffset.bWasApplied = false;
	}
};

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:270

Scope (from outer to inner):

file
function     bool FDeferredShadingSceneRenderer::ShouldRenderDistortion

Source code excerpt:

		const FViewInfo& View = Views[ViewIndex];

		if (View.bHasDistortionPrimitives && View.ShouldRenderView() && View.ParallelMeshDrawCommandPasses[EMeshPass::Distortion].HasAnyDraw())
		{
			return true;
		}
	}
	return false;
}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:512

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistortion

Source code excerpt:

	SCOPED_NAMED_EVENT(RenderDistortion, FColor::Emerald);
	RDG_EVENT_SCOPE(GraphBuilder, "Distortion");
	RDG_GPU_STAT_SCOPE(GraphBuilder, Distortion);

	const FDepthStencilBinding StencilReadBinding(SceneDepthTexture, ERenderTargetLoadAction::ELoad, ERenderTargetLoadAction::ELoad, FExclusiveDepthStencil::DepthRead_StencilRead);
	FDepthStencilBinding StencilWriteBinding(SceneDepthTexture, ERenderTargetLoadAction::ELoad, ERenderTargetLoadAction::ELoad, FExclusiveDepthStencil::DepthRead_StencilWrite);

	FRDGTextureRef DistortionTexture = nullptr;
	FRDGTextureRef RefractionVarianceCoverage = nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:720

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistortion

Source code excerpt:

				GetRefractionOffsetQuality(ShaderPlatform) > 0 ? PF_FloatRGBA : PF_B8G8R8A8,
				FClearValueBinding::Transparent,
				GFastVRamConfig.Distortion | TexCreate_RenderTargetable | TexCreate_ShaderResource,
				1,
				SceneDepthTexture->Desc.NumSamples),
			TEXT("Distortion"));

		if (bUseRoughRefraction)
		{
			// This is the texture containing information about the surface back scattering process
			RefractionVarianceCoverage = GraphBuilder.CreateTexture(
				FRDGTextureDesc::Create2D(
					SceneDepthTexture->Desc.Extent,
					PF_G16R16F,
					FClearValueBinding::Black,
					GFastVRamConfig.Distortion | TexCreate_RenderTargetable | TexCreate_ShaderResource,
					1,
					SceneDepthTexture->Desc.NumSamples),
				TEXT("RefractionVarianceCoverage"));
			RefractionClosestDepthMeter = GraphBuilder.CreateTexture(
				FRDGTextureDesc::Create2D(
					SceneDepthTexture->Desc.Extent,
					PF_R16F,
					FClearValueBinding(FLinearColor(65504.0f, 1.0f, 1.0f, 1.0f)),	// Max 16bits float depth
					GFastVRamConfig.Distortion | TexCreate_RenderTargetable | TexCreate_ShaderResource,
					1,
					SceneDepthTexture->Desc.NumSamples),
				TEXT("RefractionClosestDepthMeter"));
		}

		ERenderTargetLoadAction LoadAction = ERenderTargetLoadAction::EClear;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:775

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistortion

Source code excerpt:

			PassParameters->RenderTargets.DepthStencil = StencilWriteBinding;

			View.ParallelMeshDrawCommandPasses[EMeshPass::Distortion].BuildRenderingCommands(GraphBuilder, Scene->GPUScene, PassParameters->InstanceCullingDrawParams);

			GraphBuilder.AddPass(
				{},
				PassParameters,
				ERDGPassFlags::Raster,
				[this, &View, PassParameters](FRHICommandList& RHICmdList)

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:785

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistortion
lambda-function

Source code excerpt:

				QUICK_SCOPE_CYCLE_COUNTER(STAT_FSceneRender_RenderDistortion_Accumulate_Meshes);
				SetStereoViewport(RHICmdList, View);
				View.ParallelMeshDrawCommandPasses[EMeshPass::Distortion].DispatchDraw(nullptr, RHICmdList, &PassParameters->InstanceCullingDrawParams);
			});

			LoadAction = ERenderTargetLoadAction::ELoad;
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:1014

Scope (from outer to inner):

file
function     void FDistortionMeshProcessor::CollectPSOInitializers

Source code excerpt:

	FGraphicsPipelineRenderTargetsInfo RenderTargetsInfo;
	RenderTargetsInfo.NumSamples = 1;
	AddRenderTargetInfo(GetRefractionOffsetQuality(SceneTexturesConfig.ShaderPlatform) > 0 ? PF_FloatRGBA : PF_B8G8R8A8, GFastVRamConfig.Distortion | TexCreate_RenderTargetable | TexCreate_ShaderResource, RenderTargetsInfo);
	if (GetUseRoughRefraction())
	{
		AddRenderTargetInfo(PF_R16F, GFastVRamConfig.Distortion | TexCreate_RenderTargetable | TexCreate_ShaderResource, RenderTargetsInfo);
	}
	ETextureCreateFlags DepthStencilCreateFlags = SceneTexturesConfig.DepthCreateFlags;
	SetupDepthStencilInfo(PF_DepthStencil, DepthStencilCreateFlags, ERenderTargetLoadAction::ELoad,
		ERenderTargetLoadAction::ELoad, FExclusiveDepthStencil::DepthRead_StencilWrite, RenderTargetsInfo);

	AddGraphicsPipelineStateInitializer(

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:1116

Scope (from outer to inner):

file
function     FDistortionMeshProcessor::FDistortionMeshProcessor

Source code excerpt:

	const FMeshPassProcessorRenderState& InDistortionPassStateNoDepthTest,
	FMeshPassDrawListContext* InDrawListContext)
	: FMeshPassProcessor(EMeshPass::Distortion, Scene, FeatureLevel, InViewIfDynamicMeshCommand, InDrawListContext)
	, PassDrawRenderState(InPassDrawRenderState)
	, PassDrawRenderStateNoDepthTest(InDistortionPassStateNoDepthTest)
{}

FMeshPassProcessor* CreateDistortionPassProcessor(ERHIFeatureLevel::Type FeatureLevel, const FScene* Scene, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext)
{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistortionRendering.cpp:1179

Scope: file

Source code excerpt:

}

REGISTER_MESHPASSPROCESSOR_AND_PSOCOLLECTOR(DistortionPass, CreateDistortionPassProcessor, EShadingPath::Deferred, EMeshPass::Distortion, EMeshPassFlags::MainView);
FRegisterPassProcessorCreateFunction RegisterMobileDistortionPass(&CreateMobileDistortionPassProcessor, EShadingPath::Mobile, EMeshPass::Distortion, EMeshPassFlags::MainView);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/MobileDistortionPass.cpp:28

Scope (from outer to inner):

file
function     bool IsMobileDistortionActive

Source code excerpt:

	// Distortion on mobile requires SceneDepth information in SceneColor.A channel
	const EMobileHDRMode HDRMode = GetMobileHDRMode();
	const bool bVisiblePrims = View.ParallelMeshDrawCommandPasses[EMeshPass::Distortion].HasAnyDraw();

	return
		HDRMode == EMobileHDRMode::EnabledFloat16 &&
		View.Family->EngineShowFlags.Translucency &&
		bVisiblePrims &&
		FSceneRenderer::GetRefractionQuality(*View.Family) > 0 &&

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/MobileDistortionPass.cpp:84

Scope: file

Source code excerpt:

	const FScreenPassTextureViewport SceneColorViewport(Inputs.SceneColor);

	const_cast<FViewInfo&>(View).ParallelMeshDrawCommandPasses[EMeshPass::Distortion].BuildRenderingCommands(GraphBuilder, Scene->GPUScene, PassParameters->InstanceCullingDrawParams);

	GraphBuilder.AddPass(
		RDG_EVENT_NAME("DistortionAccumulate %dx%d", SceneColorViewport.Rect.Width(), SceneColorViewport.Rect.Height()),
		PassParameters,
		ERDGPassFlags::Raster,
		[&View, SceneColorViewport, PassParameters](FRHICommandList& RHICmdList)
	{
		RHICmdList.SetViewport(SceneColorViewport.Rect.Min.X, SceneColorViewport.Rect.Min.Y, 0.0f, SceneColorViewport.Rect.Max.X, SceneColorViewport.Rect.Max.Y, 1.0f);
		View.ParallelMeshDrawCommandPasses[EMeshPass::Distortion].DispatchDraw(nullptr, RHICmdList, &PassParameters->InstanceCullingDrawParams);
	});

	FMobileDistortionAccumulateOutputs Outputs;

	Outputs.DistortionAccumulate = DistortionAccumulateOutput;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2125

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	enum class EPass : uint32
	{
		Distortion,
		SunMask,
		BloomSetup,
		DepthOfField,
		Bloom,
		EyeAdaptation,
		SunMerge,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2287

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

		const FPostProcessMaterialChain PostProcessMaterialAfterTonemappingChain = GetPostProcessMaterialChain(View, BL_SceneColorAfterTonemapping);

		PassSequence.SetEnabled(EPass::Distortion, bUseDistortion);
		PassSequence.SetEnabled(EPass::SunMask, bUseSun || bUseDof);
		PassSequence.SetEnabled(EPass::BloomSetup, bUseSun || bUseMobileDof || bUseBloom || bUseBasicEyeAdaptation || bUseHistogramEyeAdaptation);
		PassSequence.SetEnabled(EPass::DepthOfField, bUseDof);
		PassSequence.SetEnabled(EPass::Bloom, bUseBloom);
		PassSequence.SetEnabled(EPass::EyeAdaptation, bUseEyeAdaptation);
		PassSequence.SetEnabled(EPass::SunMerge, bUseBloom || bUseSun);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2300

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

		PassSequence.Finalize();
			
		if (PassSequence.IsEnabled(EPass::Distortion))
		{
			PassSequence.AcceptPass(EPass::Distortion);
			FMobileDistortionAccumulateInputs DistortionAccumulateInputs;
			DistortionAccumulateInputs.SceneColor = SceneColor;

			FMobileDistortionAccumulateOutputs DistortionAccumulateOutputs = AddMobileDistortionAccumulatePass(GraphBuilder, Scene, View, DistortionAccumulateInputs);

			FMobileDistortionMergeInputs DistortionMergeInputs;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2660

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	else
	{
		PassSequence.SetEnabled(EPass::Distortion, false);
		PassSequence.SetEnabled(EPass::SunMask, false);
		PassSequence.SetEnabled(EPass::BloomSetup, false);
		PassSequence.SetEnabled(EPass::DepthOfField, false);
		PassSequence.SetEnabled(EPass::Bloom, false);
		PassSequence.SetEnabled(EPass::EyeAdaptation, false);
		PassSequence.SetEnabled(EPass::SunMerge, false);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:488

Scope: file

Source code excerpt:

FASTVRAM_CVAR(DistanceFieldIrradiance, 0); 
FASTVRAM_CVAR(DistanceFieldShadows, 1);
FASTVRAM_CVAR(Distortion, 1);
FASTVRAM_CVAR(ScreenSpaceShadowMask, 1);
FASTVRAM_CVAR(VolumetricFog, 1);
FASTVRAM_CVAR(SeparateTranslucency, 0); 
FASTVRAM_CVAR(SeparateTranslucencyModulate, 0);
FASTVRAM_CVAR(ScreenSpaceAO,0);
FASTVRAM_CVAR(SSR, 0);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:688

Scope (from outer to inner):

file
function     void FFastVramConfig::Update

Source code excerpt:

	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldIrradiance, DistanceFieldIrradiance);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldShadows, DistanceFieldShadows);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Distortion, Distortion);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_ScreenSpaceShadowMask, ScreenSpaceShadowMask);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_VolumetricFog, VolumetricFog);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_SeparateTranslucency, SeparateTranslucency);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_SeparateTranslucencyModulate, SeparateTranslucencyModulate);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_ScreenSpaceAO, ScreenSpaceAO);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_SSR, SSR);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.h:2838

Scope: file

Source code excerpt:

	ETextureCreateFlags DistanceFieldIrradiance;
	ETextureCreateFlags DistanceFieldAOConfidence;
	ETextureCreateFlags Distortion;
	ETextureCreateFlags ScreenSpaceShadowMask;
	ETextureCreateFlags VolumetricFog;
	ETextureCreateFlags SeparateTranslucency;
	ETextureCreateFlags SeparateTranslucencyModulate;
	ETextureCreateFlags ScreenSpaceAO;
	ETextureCreateFlags SSR;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneVisibility.cpp:1678

Scope (from outer to inner):

file
function     void FRelevancePacket::ComputeRelevance

Source code excerpt:

							if (ViewRelevance.bDistortion)
							{
								DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::Distortion);
							}
						}

#if WITH_EDITOR
						if (ViewRelevance.bEditorVisualizeLevelInstanceRelevance)
						{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneVisibility.cpp:2338

Scope (from outer to inner):

file
function     static void ComputeDynamicMeshRelevance

Source code excerpt:

		if (ViewRelevance.bDistortion)
		{
			PassMask.Set(EMeshPass::Distortion);
			View.NumVisibleDynamicMeshElements[EMeshPass::Distortion] += NumElements;
		}
	}

#if WITH_EDITOR
	if (ViewRelevance.bDrawRelevance)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Public/MeshPassProcessor.h:42

Scope (from outer to inner):

file
namespace    EMeshPass

Source code excerpt:

		CSMShadowDepth,
		VSMShadowDepth,
		Distortion,
		Velocity,
		TranslucentVelocity,
		TranslucencyStandard,
		TranslucencyStandardModulate,
		TranslucencyAfterDOF,
		TranslucencyAfterDOFModulate,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Public/MeshPassProcessor.h:93

Scope (from outer to inner):

file
function     inline const TCHAR* GetMeshPassName

Source code excerpt:

	case EMeshPass::CSMShadowDepth: return TEXT("CSMShadowDepth");
	case EMeshPass::VSMShadowDepth: return TEXT("VSMShadowDepth");
	case EMeshPass::Distortion: return TEXT("Distortion");
	case EMeshPass::Velocity: return TEXT("Velocity");
	case EMeshPass::TranslucentVelocity: return TEXT("TranslucentVelocity");
	case EMeshPass::TranslucencyStandard: return TEXT("TranslucencyStandard");
	case EMeshPass::TranslucencyStandardModulate: return TEXT("TranslucencyStandardModulate");
	case EMeshPass::TranslucencyAfterDOF: return TEXT("TranslucencyAfterDOF");
	case EMeshPass::TranslucencyAfterDOFModulate: return TEXT("TranslucencyAfterDOFModulate");