mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-29 02:47:17 +09:00
2883 lines
91 KiB
C++
2883 lines
91 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// FUNCTIONS
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Class CameraCalibrationCore.CalibrationPointComponent
|
|
// (SceneComponent, PrimitiveComponent)
|
|
|
|
class UClass* UCalibrationPointComponent::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CalibrationPointComponent");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CalibrationPointComponent CameraCalibrationCore.Default__CalibrationPointComponent
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCalibrationPointComponent* UCalibrationPointComponent::GetDefaultObj()
|
|
{
|
|
static class UCalibrationPointComponent* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCalibrationPointComponent*>(UCalibrationPointComponent::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CalibrationPointComponent.RebuildVertices
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void UCalibrationPointComponent::RebuildVertices()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CalibrationPointComponent", "RebuildVertices");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CalibrationPointComponent.NamespacedSubpointName
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString InSubpointName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString OutNamespacedName (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UCalibrationPointComponent::NamespacedSubpointName(const class FString& InSubpointName, class FString* OutNamespacedName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CalibrationPointComponent", "NamespacedSubpointName");
|
|
|
|
Params::UCalibrationPointComponent_NamespacedSubpointName_Params Parms{};
|
|
|
|
Parms.InSubpointName = InSubpointName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutNamespacedName != nullptr)
|
|
*OutNamespacedName = std::move(Parms.OutNamespacedName);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CalibrationPointComponent.GetWorldLocation
|
|
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString InPointName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector OutLocation (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UCalibrationPointComponent::GetWorldLocation(const class FString& InPointName, struct FVector* OutLocation)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CalibrationPointComponent", "GetWorldLocation");
|
|
|
|
Params::UCalibrationPointComponent_GetWorldLocation_Params Parms{};
|
|
|
|
Parms.InPointName = InPointName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutLocation != nullptr)
|
|
*OutLocation = std::move(Parms.OutLocation);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CalibrationPointComponent.GetNamespacedPointNames
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class FString> OutNamespacedNames (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
|
|
void UCalibrationPointComponent::GetNamespacedPointNames(TArray<class FString>* OutNamespacedNames)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CalibrationPointComponent", "GetNamespacedPointNames");
|
|
|
|
Params::UCalibrationPointComponent_GetNamespacedPointNames_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutNamespacedNames != nullptr)
|
|
*OutNamespacedNames = std::move(Parms.OutNamespacedNames);
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraCalibrationCheckerboard
|
|
// (Actor)
|
|
|
|
class UClass* ACameraCalibrationCheckerboard::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraCalibrationCheckerboard");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraCalibrationCheckerboard CameraCalibrationCore.Default__CameraCalibrationCheckerboard
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ACameraCalibrationCheckerboard* ACameraCalibrationCheckerboard::GetDefaultObj()
|
|
{
|
|
static class ACameraCalibrationCheckerboard* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ACameraCalibrationCheckerboard*>(ACameraCalibrationCheckerboard::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationCheckerboard.Rebuild
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void ACameraCalibrationCheckerboard::Rebuild()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationCheckerboard", "Rebuild");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraCalibrationSettings
|
|
// (None)
|
|
|
|
class UClass* UCameraCalibrationSettings::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraCalibrationSettings");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraCalibrationSettings CameraCalibrationCore.Default__CameraCalibrationSettings
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraCalibrationSettings* UCameraCalibrationSettings::GetDefaultObj()
|
|
{
|
|
static class UCameraCalibrationSettings* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraCalibrationSettings*>(UCameraCalibrationSettings::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraCalibrationEditorSettings
|
|
// (None)
|
|
|
|
class UClass* UCameraCalibrationEditorSettings::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraCalibrationEditorSettings");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraCalibrationEditorSettings CameraCalibrationCore.Default__CameraCalibrationEditorSettings
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraCalibrationEditorSettings* UCameraCalibrationEditorSettings::GetDefaultObj()
|
|
{
|
|
static class UCameraCalibrationEditorSettings* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraCalibrationEditorSettings*>(UCameraCalibrationEditorSettings::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraCalibrationStep
|
|
// (None)
|
|
|
|
class UClass* UCameraCalibrationStep::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraCalibrationStep");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraCalibrationStep CameraCalibrationCore.Default__CameraCalibrationStep
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraCalibrationStep* UCameraCalibrationStep::GetDefaultObj()
|
|
{
|
|
static class UCameraCalibrationStep* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraCalibrationStep*>(UCameraCalibrationStep::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraCalibrationSubsystem
|
|
// (None)
|
|
|
|
class UClass* UCameraCalibrationSubsystem::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraCalibrationSubsystem");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraCalibrationSubsystem CameraCalibrationCore.Default__CameraCalibrationSubsystem
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraCalibrationSubsystem* UCameraCalibrationSubsystem::GetDefaultObj()
|
|
{
|
|
static class UCameraCalibrationSubsystem* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraCalibrationSubsystem*>(UCameraCalibrationSubsystem::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.UnregisterDistortionModelHandler
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCineCameraComponent* Component (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULensDistortionModelHandlerBase*Handler (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UCameraCalibrationSubsystem::UnregisterDistortionModelHandler(class UCineCameraComponent* Component, class ULensDistortionModelHandlerBase* Handler)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "UnregisterDistortionModelHandler");
|
|
|
|
Params::UCameraCalibrationSubsystem_UnregisterDistortionModelHandler_Params Parms{};
|
|
|
|
Parms.Component = Component;
|
|
Parms.Handler = Handler;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.SetDefaultLensFile
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class ULensFile* NewDefaultLensFile (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UCameraCalibrationSubsystem::SetDefaultLensFile(class ULensFile* NewDefaultLensFile)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "SetDefaultLensFile");
|
|
|
|
Params::UCameraCalibrationSubsystem_SetDefaultLensFile_Params Parms{};
|
|
|
|
Parms.NewDefaultLensFile = NewDefaultLensFile;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetRegisteredLensModel
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName ModelName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class ULensModel> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TSubclassOf<class ULensModel> UCameraCalibrationSubsystem::GetRegisteredLensModel(class FName ModelName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetRegisteredLensModel");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetRegisteredLensModel_Params Parms{};
|
|
|
|
Parms.ModelName = ModelName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetOverlayMaterialNames
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class FName> UCameraCalibrationSubsystem::GetOverlayMaterialNames()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetOverlayMaterialNames");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetOverlayMaterialNames_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetOverlayMaterial
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName OverlayName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UMaterialInterface* UCameraCalibrationSubsystem::GetOverlayMaterial(class FName& OverlayName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetOverlayMaterial");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetOverlayMaterial_Params Parms{};
|
|
|
|
Parms.OverlayName = OverlayName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetLensFile
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLensFilePicker Picker (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class ULensFile* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULensFile* UCameraCalibrationSubsystem::GetLensFile(struct FLensFilePicker& Picker)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetLensFile");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetLensFile_Params Parms{};
|
|
|
|
Parms.Picker = Picker;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetDistortionModelHandlers
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCineCameraComponent* Component (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<class ULensDistortionModelHandlerBase*>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class ULensDistortionModelHandlerBase*> UCameraCalibrationSubsystem::GetDistortionModelHandlers(class UCineCameraComponent* Component)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetDistortionModelHandlers");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetDistortionModelHandlers_Params Parms{};
|
|
|
|
Parms.Component = Component;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetDefaultLensFile
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ULensFile* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULensFile* UCameraCalibrationSubsystem::GetDefaultLensFile()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetDefaultLensFile");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetDefaultLensFile_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraNodalOffsetAlgos
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class FName> UCameraCalibrationSubsystem::GetCameraNodalOffsetAlgos()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraNodalOffsetAlgos");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraNodalOffsetAlgos_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraNodalOffsetAlgo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName Name (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class UCameraNodalOffsetAlgo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TSubclassOf<class UCameraNodalOffsetAlgo> UCameraCalibrationSubsystem::GetCameraNodalOffsetAlgo(class FName Name)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraNodalOffsetAlgo");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraNodalOffsetAlgo_Params Parms{};
|
|
|
|
Parms.Name = Name;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraImageCenterAlgos
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class FName> UCameraCalibrationSubsystem::GetCameraImageCenterAlgos()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraImageCenterAlgos");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraImageCenterAlgos_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraImageCenterAlgo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName Name (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class UCameraImageCenterAlgo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TSubclassOf<class UCameraImageCenterAlgo> UCameraCalibrationSubsystem::GetCameraImageCenterAlgo(class FName Name)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraImageCenterAlgo");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraImageCenterAlgo_Params Parms{};
|
|
|
|
Parms.Name = Name;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraCalibrationSteps
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class FName> UCameraCalibrationSubsystem::GetCameraCalibrationSteps()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraCalibrationSteps");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraCalibrationSteps_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.GetCameraCalibrationStep
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName Name (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class UCameraCalibrationStep>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TSubclassOf<class UCameraCalibrationStep> UCameraCalibrationSubsystem::GetCameraCalibrationStep(class FName Name)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "GetCameraCalibrationStep");
|
|
|
|
Params::UCameraCalibrationSubsystem_GetCameraCalibrationStep_Params Parms{};
|
|
|
|
Parms.Name = Name;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.FindOrCreateDistortionModelHandler
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FDistortionHandlerPicker DistortionHandlerPicker (Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class ULensModel> LensModelClass (ConstParm, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULensDistortionModelHandlerBase*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULensDistortionModelHandlerBase* UCameraCalibrationSubsystem::FindOrCreateDistortionModelHandler(struct FDistortionHandlerPicker& DistortionHandlerPicker, TSubclassOf<class ULensModel> LensModelClass)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "FindOrCreateDistortionModelHandler");
|
|
|
|
Params::UCameraCalibrationSubsystem_FindOrCreateDistortionModelHandler_Params Parms{};
|
|
|
|
Parms.DistortionHandlerPicker = DistortionHandlerPicker;
|
|
Parms.LensModelClass = LensModelClass;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.CameraCalibrationSubsystem.FindDistortionModelHandler
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FDistortionHandlerPicker DistortionHandlerPicker (Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// bool bUpdatePicker (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULensDistortionModelHandlerBase*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULensDistortionModelHandlerBase* UCameraCalibrationSubsystem::FindDistortionModelHandler(struct FDistortionHandlerPicker& DistortionHandlerPicker, bool bUpdatePicker)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CameraCalibrationSubsystem", "FindDistortionModelHandler");
|
|
|
|
Params::UCameraCalibrationSubsystem_FindDistortionModelHandler_Params Parms{};
|
|
|
|
Parms.DistortionHandlerPicker = DistortionHandlerPicker;
|
|
Parms.bUpdatePicker = bUpdatePicker;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraImageCenterAlgo
|
|
// (None)
|
|
|
|
class UClass* UCameraImageCenterAlgo::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraImageCenterAlgo");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraImageCenterAlgo CameraCalibrationCore.Default__CameraImageCenterAlgo
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraImageCenterAlgo* UCameraImageCenterAlgo::GetDefaultObj()
|
|
{
|
|
static class UCameraImageCenterAlgo* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraImageCenterAlgo*>(UCameraImageCenterAlgo::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraLensDistortionAlgo
|
|
// (None)
|
|
|
|
class UClass* UCameraLensDistortionAlgo::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraLensDistortionAlgo");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraLensDistortionAlgo CameraCalibrationCore.Default__CameraLensDistortionAlgo
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraLensDistortionAlgo* UCameraLensDistortionAlgo::GetDefaultObj()
|
|
{
|
|
static class UCameraLensDistortionAlgo* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraLensDistortionAlgo*>(UCameraLensDistortionAlgo::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.CameraNodalOffsetAlgo
|
|
// (None)
|
|
|
|
class UClass* UCameraNodalOffsetAlgo::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CameraNodalOffsetAlgo");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CameraNodalOffsetAlgo CameraCalibrationCore.Default__CameraNodalOffsetAlgo
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCameraNodalOffsetAlgo* UCameraNodalOffsetAlgo::GetDefaultObj()
|
|
{
|
|
static class UCameraNodalOffsetAlgo* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCameraNodalOffsetAlgo*>(UCameraNodalOffsetAlgo::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.LensComponent
|
|
// (None)
|
|
|
|
class UClass* ULensComponent::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LensComponent");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LensComponent CameraCalibrationCore.Default__LensComponent
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULensComponent* ULensComponent::GetDefaultObj()
|
|
{
|
|
static class ULensComponent* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULensComponent*>(ULensComponent::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.WasNodalOffsetAppliedThisTick
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensComponent::WasNodalOffsetAppliedThisTick()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "WasNodalOffsetAppliedThisTick");
|
|
|
|
Params::ULensComponent_WasNodalOffsetAppliedThisTick_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.WasDistortionEvaluated
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensComponent::WasDistortionEvaluated()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "WasDistortionEvaluated");
|
|
|
|
Params::ULensComponent_WasDistortionEvaluated_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.ShouldApplyNodalOffsetOnTick
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensComponent::ShouldApplyNodalOffsetOnTick()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "ShouldApplyNodalOffsetOnTick");
|
|
|
|
Params::ULensComponent_ShouldApplyNodalOffsetOnTick_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.ShouldApplyDistortion
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensComponent::ShouldApplyDistortion()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "ShouldApplyDistortion");
|
|
|
|
Params::ULensComponent_ShouldApplyDistortion_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetOverscanMultiplier
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Multiplier (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetOverscanMultiplier(float Multiplier)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetOverscanMultiplier");
|
|
|
|
Params::ULensComponent_SetOverscanMultiplier_Params Parms{};
|
|
|
|
Parms.Multiplier = Multiplier;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetLensModel
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class ULensModel> Model (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetLensModel(TSubclassOf<class ULensModel> Model)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetLensModel");
|
|
|
|
Params::ULensComponent_SetLensModel_Params Parms{};
|
|
|
|
Parms.Model = Model;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetLensFilePicker
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLensFilePicker LensFile (Parm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetLensFilePicker(const struct FLensFilePicker& LensFile)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetLensFilePicker");
|
|
|
|
Params::ULensComponent_SetLensFilePicker_Params Parms{};
|
|
|
|
Parms.LensFile = LensFile;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetLensFile
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class ULensFile* LensFile (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetLensFile(class ULensFile* LensFile)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetLensFile");
|
|
|
|
Params::ULensComponent_SetLensFile_Params Parms{};
|
|
|
|
Parms.LensFile = LensFile;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetFIZEvaluationMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class EFIZEvaluationMode Mode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetFIZEvaluationMode(enum class EFIZEvaluationMode Mode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetFIZEvaluationMode");
|
|
|
|
Params::ULensComponent_SetFIZEvaluationMode_Params Parms{};
|
|
|
|
Parms.Mode = Mode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetFilmbackOverrideSetting
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class EFilmbackOverrideSource Setting (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetFilmbackOverrideSetting(enum class EFilmbackOverrideSource Setting)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetFilmbackOverrideSetting");
|
|
|
|
Params::ULensComponent_SetFilmbackOverrideSetting_Params Parms{};
|
|
|
|
Parms.Setting = Setting;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetDistortionState
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLensDistortionState State (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetDistortionState(const struct FLensDistortionState& State)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetDistortionState");
|
|
|
|
Params::ULensComponent_SetDistortionState_Params Parms{};
|
|
|
|
Parms.State = State;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetDistortionSource
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class EDistortionSource Source (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetDistortionSource(enum class EDistortionSource Source)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetDistortionSource");
|
|
|
|
Params::ULensComponent_SetDistortionSource_Params Parms{};
|
|
|
|
Parms.Source = Source;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetCroppedFilmback
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FCameraFilmbackSettings Filmback (Parm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetCroppedFilmback(const struct FCameraFilmbackSettings& Filmback)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetCroppedFilmback");
|
|
|
|
Params::ULensComponent_SetCroppedFilmback_Params Parms{};
|
|
|
|
Parms.Filmback = Filmback;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetApplyNodalOffsetOnTick
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bApplyNodalOffset (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetApplyNodalOffsetOnTick(bool bApplyNodalOffset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetApplyNodalOffsetOnTick");
|
|
|
|
Params::ULensComponent_SetApplyNodalOffsetOnTick_Params Parms{};
|
|
|
|
Parms.bApplyNodalOffset = bApplyNodalOffset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.SetApplyDistortion
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bApply (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::SetApplyDistortion(bool bApply)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "SetApplyDistortion");
|
|
|
|
Params::ULensComponent_SetApplyDistortion_Params Parms{};
|
|
|
|
Parms.bApply = bApply;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetOverscanMultiplier
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float ULensComponent::GetOverscanMultiplier()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetOverscanMultiplier");
|
|
|
|
Params::ULensComponent_GetOverscanMultiplier_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetOriginalFocalLength
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float ULensComponent::GetOriginalFocalLength()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetOriginalFocalLength");
|
|
|
|
Params::ULensComponent_GetOriginalFocalLength_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetLensModel
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TSubclassOf<class ULensModel> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TSubclassOf<class ULensModel> ULensComponent::GetLensModel()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetLensModel");
|
|
|
|
Params::ULensComponent_GetLensModel_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetLensFilePicker
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLensFilePicker ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FLensFilePicker ULensComponent::GetLensFilePicker()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetLensFilePicker");
|
|
|
|
Params::ULensComponent_GetLensFilePicker_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetLensFileEvaluationInputs
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLensFileEvaluationInputs ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FLensFileEvaluationInputs ULensComponent::GetLensFileEvaluationInputs()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetLensFileEvaluationInputs");
|
|
|
|
Params::ULensComponent_GetLensFileEvaluationInputs_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetLensFile
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ULensFile* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULensFile* ULensComponent::GetLensFile()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetLensFile");
|
|
|
|
Params::ULensComponent_GetLensFile_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetFIZEvaluationMode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// enum class EFIZEvaluationMode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
enum class EFIZEvaluationMode ULensComponent::GetFIZEvaluationMode()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetFIZEvaluationMode");
|
|
|
|
Params::ULensComponent_GetFIZEvaluationMode_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetFilmbackOverrideSetting
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// enum class EFilmbackOverrideSource ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
enum class EFilmbackOverrideSource ULensComponent::GetFilmbackOverrideSetting()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetFilmbackOverrideSetting");
|
|
|
|
Params::ULensComponent_GetFilmbackOverrideSetting_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetDistortionState
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLensDistortionState ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FLensDistortionState ULensComponent::GetDistortionState()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetDistortionState");
|
|
|
|
Params::ULensComponent_GetDistortionState_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetDistortionSource
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// enum class EDistortionSource ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
enum class EDistortionSource ULensComponent::GetDistortionSource()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetDistortionSource");
|
|
|
|
Params::ULensComponent_GetDistortionSource_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.GetCroppedFilmback
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FCameraFilmbackSettings ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FCameraFilmbackSettings ULensComponent::GetCroppedFilmback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "GetCroppedFilmback");
|
|
|
|
Params::ULensComponent_GetCroppedFilmback_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.ClearDistortionState
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void ULensComponent::ClearDistortionState()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "ClearDistortionState");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensComponent.ApplyNodalOffset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* ComponentToOffset (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bUseManualInputs (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ManualFocusInput (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ManualZoomInput (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensComponent::ApplyNodalOffset(class USceneComponent* ComponentToOffset, bool bUseManualInputs, float ManualFocusInput, float ManualZoomInput)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensComponent", "ApplyNodalOffset");
|
|
|
|
Params::ULensComponent_ApplyNodalOffset_Params Parms{};
|
|
|
|
Parms.ComponentToOffset = ComponentToOffset;
|
|
Parms.bUseManualInputs = bUseManualInputs;
|
|
Parms.ManualFocusInput = ManualFocusInput;
|
|
Parms.ManualZoomInput = ManualZoomInput;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.LensDistortionModelHandlerBase
|
|
// (None)
|
|
|
|
class UClass* ULensDistortionModelHandlerBase::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LensDistortionModelHandlerBase");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LensDistortionModelHandlerBase CameraCalibrationCore.Default__LensDistortionModelHandlerBase
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULensDistortionModelHandlerBase* ULensDistortionModelHandlerBase::GetDefaultObj()
|
|
{
|
|
static class ULensDistortionModelHandlerBase* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULensDistortionModelHandlerBase*>(ULensDistortionModelHandlerBase::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensDistortionModelHandlerBase.SetDistortionState
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLensDistortionState InNewState (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void ULensDistortionModelHandlerBase::SetDistortionState(struct FLensDistortionState& InNewState)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensDistortionModelHandlerBase", "SetDistortionState");
|
|
|
|
Params::ULensDistortionModelHandlerBase_SetDistortionState_Params Parms{};
|
|
|
|
Parms.InNewState = InNewState;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensDistortionModelHandlerBase.IsModelSupported
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TSubclassOf<class ULensModel> ModelToSupport (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensDistortionModelHandlerBase::IsModelSupported(TSubclassOf<class ULensModel>& ModelToSupport)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensDistortionModelHandlerBase", "IsModelSupported");
|
|
|
|
Params::ULensDistortionModelHandlerBase_IsModelSupported_Params Parms{};
|
|
|
|
Parms.ModelToSupport = ModelToSupport;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensDistortionModelHandlerBase.GetUndistortionDisplacementMap
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UTextureRenderTarget2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UTextureRenderTarget2D* ULensDistortionModelHandlerBase::GetUndistortionDisplacementMap()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensDistortionModelHandlerBase", "GetUndistortionDisplacementMap");
|
|
|
|
Params::ULensDistortionModelHandlerBase_GetUndistortionDisplacementMap_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensDistortionModelHandlerBase.GetDistortionDisplacementMap
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UTextureRenderTarget2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UTextureRenderTarget2D* ULensDistortionModelHandlerBase::GetDistortionDisplacementMap()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensDistortionModelHandlerBase", "GetDistortionDisplacementMap");
|
|
|
|
Params::ULensDistortionModelHandlerBase_GetDistortionDisplacementMap_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.LensFile
|
|
// (None)
|
|
|
|
class UClass* ULensFile::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LensFile");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LensFile CameraCalibrationCore.Default__LensFile
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULensFile* ULensFile::GetDefaultObj()
|
|
{
|
|
static class ULensFile* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULensFile*>(ULensFile::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.RemoveZoomPoint
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class ELensDataCategory InDataCategory (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::RemoveZoomPoint(enum class ELensDataCategory InDataCategory, float InFocus, float InZoom)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "RemoveZoomPoint");
|
|
|
|
Params::ULensFile_RemoveZoomPoint_Params Parms{};
|
|
|
|
Parms.InDataCategory = InDataCategory;
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.RemoveFocusPoint
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class ELensDataCategory InDataCategory (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::RemoveFocusPoint(enum class ELensDataCategory InDataCategory, float InFocus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "RemoveFocusPoint");
|
|
|
|
Params::ULensFile_RemoveFocusPoint_Params Parms{};
|
|
|
|
Parms.InDataCategory = InDataCategory;
|
|
Parms.InFocus = InFocus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.HasSamples
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// enum class ELensDataCategory InDataCategory (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::HasSamples(enum class ELensDataCategory InDataCategory)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "HasSamples");
|
|
|
|
Params::ULensFile_HasSamples_Params Parms{};
|
|
|
|
Parms.InDataCategory = InDataCategory;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.HasIrisEncoderMapping
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::HasIrisEncoderMapping()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "HasIrisEncoderMapping");
|
|
|
|
Params::ULensFile_HasIrisEncoderMapping_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.HasFocusEncoderMapping
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::HasFocusEncoderMapping()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "HasFocusEncoderMapping");
|
|
|
|
Params::ULensFile_HasFocusEncoderMapping_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetTotalPointNum
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// enum class ELensDataCategory InDataCategory (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 ULensFile::GetTotalPointNum(enum class ELensDataCategory InDataCategory)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetTotalPointNum");
|
|
|
|
Params::ULensFile_GetTotalPointNum_Params Parms{};
|
|
|
|
Parms.InDataCategory = InDataCategory;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetSTMapPoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FSTMapPointInfo> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FSTMapPointInfo> ULensFile::GetSTMapPoints()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetSTMapPoints");
|
|
|
|
Params::ULensFile_GetSTMapPoints_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetSTMapPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSTMapInfo OutSTMapInfo (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::GetSTMapPoint(float InFocus, float InZoom, struct FSTMapInfo* OutSTMapInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetSTMapPoint");
|
|
|
|
Params::ULensFile_GetSTMapPoint_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutSTMapInfo != nullptr)
|
|
*OutSTMapInfo = std::move(Parms.OutSTMapInfo);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetNodalOffsetPoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FNodalOffsetPointInfo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FNodalOffsetPointInfo> ULensFile::GetNodalOffsetPoints()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetNodalOffsetPoints");
|
|
|
|
Params::ULensFile_GetNodalOffsetPoints_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetNodalOffsetPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FNodalPointOffset OutNodalPointOffset (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::GetNodalOffsetPoint(float InFocus, float InZoom, struct FNodalPointOffset* OutNodalPointOffset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetNodalOffsetPoint");
|
|
|
|
Params::ULensFile_GetNodalOffsetPoint_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutNodalPointOffset != nullptr)
|
|
*OutNodalPointOffset = std::move(Parms.OutNodalPointOffset);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetImageCenterPoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FImageCenterPointInfo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FImageCenterPointInfo> ULensFile::GetImageCenterPoints()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetImageCenterPoints");
|
|
|
|
Params::ULensFile_GetImageCenterPoints_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetImageCenterPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FImageCenterInfo OutImageCenterInfo (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::GetImageCenterPoint(float InFocus, float InZoom, struct FImageCenterInfo* OutImageCenterInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetImageCenterPoint");
|
|
|
|
Params::ULensFile_GetImageCenterPoint_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutImageCenterInfo != nullptr)
|
|
*OutImageCenterInfo = std::move(Parms.OutImageCenterInfo);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetFocalLengthPoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FFocalLengthPointInfo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FFocalLengthPointInfo> ULensFile::GetFocalLengthPoints()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetFocalLengthPoints");
|
|
|
|
Params::ULensFile_GetFocalLengthPoints_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetFocalLengthPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FFocalLengthInfo OutFocalLengthInfo (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::GetFocalLengthPoint(float InFocus, float InZoom, struct FFocalLengthInfo* OutFocalLengthInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetFocalLengthPoint");
|
|
|
|
Params::ULensFile_GetFocalLengthPoint_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutFocalLengthInfo != nullptr)
|
|
*OutFocalLengthInfo = std::move(Parms.OutFocalLengthInfo);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetDistortionPoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FDistortionPointInfo>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FDistortionPointInfo> ULensFile::GetDistortionPoints()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetDistortionPoints");
|
|
|
|
Params::ULensFile_GetDistortionPoints_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.GetDistortionPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FDistortionInfo OutDistortionInfo (Parm, OutParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::GetDistortionPoint(float InFocus, float InZoom, struct FDistortionInfo* OutDistortionInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "GetDistortionPoint");
|
|
|
|
Params::ULensFile_GetDistortionPoint_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutDistortionInfo != nullptr)
|
|
*OutDistortionInfo = std::move(Parms.OutDistortionInfo);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateNormalizedIris
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InNormalizedValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float ULensFile::EvaluateNormalizedIris(float InNormalizedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateNormalizedIris");
|
|
|
|
Params::ULensFile_EvaluateNormalizedIris_Params Parms{};
|
|
|
|
Parms.InNormalizedValue = InNormalizedValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateNormalizedFocus
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InNormalizedValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float ULensFile::EvaluateNormalizedFocus(float InNormalizedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateNormalizedFocus");
|
|
|
|
Params::ULensFile_EvaluateNormalizedFocus_Params Parms{};
|
|
|
|
Parms.InNormalizedValue = InNormalizedValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateNodalPointOffset
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FNodalPointOffset OutEvaluatedValue (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::EvaluateNodalPointOffset(float InFocus, float InZoom, struct FNodalPointOffset* OutEvaluatedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateNodalPointOffset");
|
|
|
|
Params::ULensFile_EvaluateNodalPointOffset_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutEvaluatedValue != nullptr)
|
|
*OutEvaluatedValue = std::move(Parms.OutEvaluatedValue);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateImageCenterParameters
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FImageCenterInfo OutEvaluatedValue (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::EvaluateImageCenterParameters(float InFocus, float InZoom, struct FImageCenterInfo* OutEvaluatedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateImageCenterParameters");
|
|
|
|
Params::ULensFile_EvaluateImageCenterParameters_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutEvaluatedValue != nullptr)
|
|
*OutEvaluatedValue = std::move(Parms.OutEvaluatedValue);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateFocalLength
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FFocalLengthInfo OutEvaluatedValue (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::EvaluateFocalLength(float InFocus, float InZoom, struct FFocalLengthInfo* OutEvaluatedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateFocalLength");
|
|
|
|
Params::ULensFile_EvaluateFocalLength_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutEvaluatedValue != nullptr)
|
|
*OutEvaluatedValue = std::move(Parms.OutEvaluatedValue);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateDistortionParameters
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FDistortionInfo OutEvaluatedValue (Parm, OutParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::EvaluateDistortionParameters(float InFocus, float InZoom, struct FDistortionInfo* OutEvaluatedValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateDistortionParameters");
|
|
|
|
Params::ULensFile_EvaluateDistortionParameters_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutEvaluatedValue != nullptr)
|
|
*OutEvaluatedValue = std::move(Parms.OutEvaluatedValue);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.EvaluateDistortionData
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector2D InFilmback (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULensDistortionModelHandlerBase*InLensHandler (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULensFile::EvaluateDistortionData(float InFocus, float InZoom, const struct FVector2D& InFilmback, class ULensDistortionModelHandlerBase* InLensHandler)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "EvaluateDistortionData");
|
|
|
|
Params::ULensFile_EvaluateDistortionData_Params Parms{};
|
|
|
|
Parms.InFocus = InFocus;
|
|
Parms.InZoom = InZoom;
|
|
Parms.InFilmback = InFilmback;
|
|
Parms.InLensHandler = InLensHandler;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.ClearData
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// enum class ELensDataCategory InDataCategory (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::ClearData(enum class ELensDataCategory InDataCategory)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "ClearData");
|
|
|
|
Params::ULensFile_ClearData_Params Parms{};
|
|
|
|
Parms.InDataCategory = InDataCategory;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.ClearAll
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void ULensFile::ClearAll()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "ClearAll");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.AddSTMapPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float NewZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSTMapInfo NewPoint (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::AddSTMapPoint(float NewFocus, float NewZoom, struct FSTMapInfo& NewPoint)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "AddSTMapPoint");
|
|
|
|
Params::ULensFile_AddSTMapPoint_Params Parms{};
|
|
|
|
Parms.NewFocus = NewFocus;
|
|
Parms.NewZoom = NewZoom;
|
|
Parms.NewPoint = NewPoint;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.AddNodalOffsetPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float NewZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FNodalPointOffset NewPoint (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::AddNodalOffsetPoint(float NewFocus, float NewZoom, struct FNodalPointOffset& NewPoint)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "AddNodalOffsetPoint");
|
|
|
|
Params::ULensFile_AddNodalOffsetPoint_Params Parms{};
|
|
|
|
Parms.NewFocus = NewFocus;
|
|
Parms.NewZoom = NewZoom;
|
|
Parms.NewPoint = NewPoint;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.AddImageCenterPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float NewZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FImageCenterInfo NewPoint (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::AddImageCenterPoint(float NewFocus, float NewZoom, struct FImageCenterInfo& NewPoint)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "AddImageCenterPoint");
|
|
|
|
Params::ULensFile_AddImageCenterPoint_Params Parms{};
|
|
|
|
Parms.NewFocus = NewFocus;
|
|
Parms.NewZoom = NewZoom;
|
|
Parms.NewPoint = NewPoint;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.AddFocalLengthPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float NewZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FFocalLengthInfo NewFocalLength (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::AddFocalLengthPoint(float NewFocus, float NewZoom, struct FFocalLengthInfo& NewFocalLength)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "AddFocalLengthPoint");
|
|
|
|
Params::ULensFile_AddFocalLengthPoint_Params Parms{};
|
|
|
|
Parms.NewFocus = NewFocus;
|
|
Parms.NewZoom = NewZoom;
|
|
Parms.NewFocalLength = NewFocalLength;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function CameraCalibrationCore.LensFile.AddDistortionPoint
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFocus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float NewZoom (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FDistortionInfo NewPoint (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FFocalLengthInfo NewFocalLength (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void ULensFile::AddDistortionPoint(float NewFocus, float NewZoom, struct FDistortionInfo& NewPoint, struct FFocalLengthInfo& NewFocalLength)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LensFile", "AddDistortionPoint");
|
|
|
|
Params::ULensFile_AddDistortionPoint_Params Parms{};
|
|
|
|
Parms.NewFocus = NewFocus;
|
|
Parms.NewZoom = NewZoom;
|
|
Parms.NewPoint = NewPoint;
|
|
Parms.NewFocalLength = NewFocalLength;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.LensModel
|
|
// (None)
|
|
|
|
class UClass* ULensModel::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LensModel");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LensModel CameraCalibrationCore.Default__LensModel
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULensModel* ULensModel::GetDefaultObj()
|
|
{
|
|
static class ULensModel* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULensModel*>(ULensModel::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.SphericalLensDistortionModelHandler
|
|
// (None)
|
|
|
|
class UClass* USphericalLensDistortionModelHandler::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SphericalLensDistortionModelHandler");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SphericalLensDistortionModelHandler CameraCalibrationCore.Default__SphericalLensDistortionModelHandler
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USphericalLensDistortionModelHandler* USphericalLensDistortionModelHandler::GetDefaultObj()
|
|
{
|
|
static class USphericalLensDistortionModelHandler* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USphericalLensDistortionModelHandler*>(USphericalLensDistortionModelHandler::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class CameraCalibrationCore.SphericalLensModel
|
|
// (None)
|
|
|
|
class UClass* USphericalLensModel::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SphericalLensModel");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SphericalLensModel CameraCalibrationCore.Default__SphericalLensModel
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USphericalLensModel* USphericalLensModel::GetDefaultObj()
|
|
{
|
|
static class USphericalLensModel* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USphericalLensModel*>(USphericalLensModel::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
}
|
|
|
|
|