// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
	Generated code exported from UnrealHeaderTool.
	DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/

#include "UObject/GeneratedCppIncludes.h"
#include "SceneQueries/SceneSnappingManager.h"

PRAGMA_DISABLE_DEPRECATION_WARNINGS
static_assert(!UE_WITH_CONSTINIT_UOBJECT, "This generated code can only be compiled with !UE_WITH_CONSTINIT_OBJECT");
void EmptyLinkFunctionForGeneratedCodeSceneSnappingManager() {}

// ********** Begin Cross Module References ********************************************************
COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
INTERACTIVETOOLSFRAMEWORK_API UClass* Z_Construct_UClass_USceneSnappingManager();
INTERACTIVETOOLSFRAMEWORK_API UClass* Z_Construct_UClass_USceneSnappingManager_NoRegister();
INTERACTIVETOOLSFRAMEWORK_API UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult();
INTERACTIVETOOLSFRAMEWORK_API UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType();
INTERACTIVETOOLSFRAMEWORK_API UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType();
UPackage* Z_Construct_UPackage__Script_InteractiveToolsFramework();
// ********** End Cross Module References **********************************************************

// ********** Begin Enum ESceneSnapQueryType *******************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ESceneSnapQueryType;
static UEnum* ESceneSnapQueryType_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryType.OuterSingleton)
	{
		Z_Registration_Info_UEnum_ESceneSnapQueryType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType, (UObject*)Z_Construct_UPackage__Script_InteractiveToolsFramework(), TEXT("ESceneSnapQueryType"));
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryType.OuterSingleton;
}
template<> INTERACTIVETOOLSFRAMEWORK_NON_ATTRIBUTED_API UEnum* StaticEnum<ESceneSnapQueryType>()
{
	return ESceneSnapQueryType_StaticEnum();
}
struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Comment", "/** Types of Snap Queries that a USceneSnappingManager may support */" },
		{ "ModuleRelativePath", "Public/SceneQueries/SceneSnappingManager.h" },
		{ "Position.Comment", "/** Position/Translation snapping */" },
		{ "Position.Name", "ESceneSnapQueryType::Position" },
		{ "Position.ToolTip", "Position/Translation snapping" },
		{ "Rotation.Comment", "/** Full rotation snapping (which could affect the axis of rotation) */" },
		{ "Rotation.Name", "ESceneSnapQueryType::Rotation" },
		{ "Rotation.ToolTip", "Full rotation snapping (which could affect the axis of rotation)" },
		{ "RotationAngle.Comment", "/** Snaps the rotation angle only (in degrees). */" },
		{ "RotationAngle.Name", "ESceneSnapQueryType::RotationAngle" },
		{ "RotationAngle.ToolTip", "Snaps the rotation angle only (in degrees)." },
		{ "Scale.Comment", "/** Scale snapping */" },
		{ "Scale.Name", "ESceneSnapQueryType::Scale" },
		{ "Scale.ToolTip", "Scale snapping" },
		{ "ToolTip", "Types of Snap Queries that a USceneSnappingManager may support" },
		{ "Transform.Comment", "/** Transform snapping (ie. snap to surface is both position and rotation) */" },
		{ "Transform.Name", "ESceneSnapQueryType::Transform" },
		{ "Transform.ToolTip", "Transform snapping (ie. snap to surface is both position and rotation)" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "ESceneSnapQueryType::Position", (int64)ESceneSnapQueryType::Position },
		{ "ESceneSnapQueryType::Rotation", (int64)ESceneSnapQueryType::Rotation },
		{ "ESceneSnapQueryType::RotationAngle", (int64)ESceneSnapQueryType::RotationAngle },
		{ "ESceneSnapQueryType::Scale", (int64)ESceneSnapQueryType::Scale },
		{ "ESceneSnapQueryType::Transform", (int64)ESceneSnapQueryType::Transform },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_InteractiveToolsFramework,
	nullptr,
	"ESceneSnapQueryType",
	"ESceneSnapQueryType",
	Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryType.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ESceneSnapQueryType.InnerSingleton, Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryType_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryType.InnerSingleton;
}
// ********** End Enum ESceneSnapQueryType *********************************************************

// ********** Begin Enum ESceneSnapQueryTargetType *************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ESceneSnapQueryTargetType;
static UEnum* ESceneSnapQueryTargetType_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.OuterSingleton)
	{
		Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType, (UObject*)Z_Construct_UPackage__Script_InteractiveToolsFramework(), TEXT("ESceneSnapQueryTargetType"));
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.OuterSingleton;
}
template<> INTERACTIVETOOLSFRAMEWORK_NON_ATTRIBUTED_API UEnum* StaticEnum<ESceneSnapQueryTargetType>()
{
	return ESceneSnapQueryTargetType_StaticEnum();
}
struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "All.Name", "ESceneSnapQueryTargetType::All" },
		{ "Comment", "/** Types of Snap Targets that a caller may want to run snap queries against. */" },
		{ "Custom.Comment", "/** As defined by an FName */" },
		{ "Custom.Name", "ESceneSnapQueryTargetType::Custom" },
		{ "Custom.ToolTip", "As defined by an FName" },
		{ "Grid.Comment", "/** Grid Snapping */" },
		{ "Grid.Name", "ESceneSnapQueryTargetType::Grid" },
		{ "Grid.ToolTip", "Grid Snapping" },
		{ "MeshEdge.Comment", "/** Consider any mesh edge */" },
		{ "MeshEdge.Name", "ESceneSnapQueryTargetType::MeshEdge" },
		{ "MeshEdge.ToolTip", "Consider any mesh edge" },
		{ "MeshVertex.Comment", "/** Consider any mesh vertex */" },
		{ "MeshVertex.Name", "ESceneSnapQueryTargetType::MeshVertex" },
		{ "MeshVertex.ToolTip", "Consider any mesh vertex" },
		{ "ModuleRelativePath", "Public/SceneQueries/SceneSnappingManager.h" },
		{ "None.Name", "ESceneSnapQueryTargetType::None" },
		{ "ObjectTransform.Comment", "/** Any object with a transform representation  */" },
		{ "ObjectTransform.Name", "ESceneSnapQueryTargetType::ObjectTransform" },
		{ "ObjectTransform.ToolTip", "Any object with a transform representation" },
		{ "ToolTip", "Types of Snap Targets that a caller may want to run snap queries against." },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "ESceneSnapQueryTargetType::None", (int64)ESceneSnapQueryTargetType::None },
		{ "ESceneSnapQueryTargetType::MeshVertex", (int64)ESceneSnapQueryTargetType::MeshVertex },
		{ "ESceneSnapQueryTargetType::MeshEdge", (int64)ESceneSnapQueryTargetType::MeshEdge },
		{ "ESceneSnapQueryTargetType::Grid", (int64)ESceneSnapQueryTargetType::Grid },
		{ "ESceneSnapQueryTargetType::ObjectTransform", (int64)ESceneSnapQueryTargetType::ObjectTransform },
		{ "ESceneSnapQueryTargetType::Custom", (int64)ESceneSnapQueryTargetType::Custom },
		{ "ESceneSnapQueryTargetType::All", (int64)ESceneSnapQueryTargetType::All },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_InteractiveToolsFramework,
	nullptr,
	"ESceneSnapQueryTargetType",
	"ESceneSnapQueryTargetType",
	Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.InnerSingleton, Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetType_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryTargetType.InnerSingleton;
}
// ********** End Enum ESceneSnapQueryTargetType ***************************************************

// ********** Begin Enum ESceneSnapQueryTargetResult ***********************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult;
static UEnum* ESceneSnapQueryTargetResult_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.OuterSingleton)
	{
		Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult, (UObject*)Z_Construct_UPackage__Script_InteractiveToolsFramework(), TEXT("ESceneSnapQueryTargetResult"));
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.OuterSingleton;
}
template<> INTERACTIVETOOLSFRAMEWORK_NON_ATTRIBUTED_API UEnum* StaticEnum<ESceneSnapQueryTargetResult>()
{
	return ESceneSnapQueryTargetResult_StaticEnum();
}
struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Comment", "/** Describes the result of the attempted snap operation.\n * Note that this differs to FSceneSnapQueryResult in that it only\n * indicates the success or failure of the snap, not the resulting data. */" },
		{ "Disabled.Comment", "/** Snapping is valid and supported, but is disabled (usually due to a user setting). */" },
		{ "Disabled.Name", "ESceneSnapQueryTargetResult::Disabled" },
		{ "Disabled.ToolTip", "Snapping is valid and supported, but is disabled (usually due to a user setting)." },
		{ "ModuleRelativePath", "Public/SceneQueries/SceneSnappingManager.h" },
		{ "NotSnapped.Comment", "/** Snapping was valid and attempted, but did not snap to target. */" },
		{ "NotSnapped.Name", "ESceneSnapQueryTargetResult::NotSnapped" },
		{ "NotSnapped.ToolTip", "Snapping was valid and attempted, but did not snap to target." },
		{ "Snapped.Comment", "/** Snapping was valid and attempted, and did snap to target. This may indicate no further snapping operations should be attempted for the given interaction. */" },
		{ "Snapped.Name", "ESceneSnapQueryTargetResult::Snapped" },
		{ "Snapped.ToolTip", "Snapping was valid and attempted, and did snap to target. This may indicate no further snapping operations should be attempted for the given interaction." },
		{ "ToolTip", "Describes the result of the attempted snap operation.\nNote that this differs to FSceneSnapQueryResult in that it only\nindicates the success or failure of the snap, not the resulting data." },
		{ "Unsupported.Comment", "/** The snapping query isn't valid for this Query Target. */" },
		{ "Unsupported.Name", "ESceneSnapQueryTargetResult::Unsupported" },
		{ "Unsupported.ToolTip", "The snapping query isn't valid for this Query Target." },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "ESceneSnapQueryTargetResult::NotSnapped", (int64)ESceneSnapQueryTargetResult::NotSnapped },
		{ "ESceneSnapQueryTargetResult::Snapped", (int64)ESceneSnapQueryTargetResult::Snapped },
		{ "ESceneSnapQueryTargetResult::Disabled", (int64)ESceneSnapQueryTargetResult::Disabled },
		{ "ESceneSnapQueryTargetResult::Unsupported", (int64)ESceneSnapQueryTargetResult::Unsupported },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_InteractiveToolsFramework,
	nullptr,
	"ESceneSnapQueryTargetResult",
	"ESceneSnapQueryTargetResult",
	Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::Enum_MetaDataParams), Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult()
{
	if (!Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.InnerSingleton, Z_Construct_UEnum_InteractiveToolsFramework_ESceneSnapQueryTargetResult_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult.InnerSingleton;
}
// ********** End Enum ESceneSnapQueryTargetResult *************************************************

// ********** Begin Class USceneSnappingManager ****************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_USceneSnappingManager;
UClass* USceneSnappingManager::GetPrivateStaticClass()
{
	using TClass = USceneSnappingManager;
	if (!Z_Registration_Info_UClass_USceneSnappingManager.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("SceneSnappingManager"),
			Z_Registration_Info_UClass_USceneSnappingManager.InnerSingleton,
			StaticRegisterNativesUSceneSnappingManager,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_USceneSnappingManager.InnerSingleton;
}
UClass* Z_Construct_UClass_USceneSnappingManager_NoRegister()
{
	return USceneSnappingManager::GetPrivateStaticClass();
}
struct Z_Construct_UClass_USceneSnappingManager_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "Comment", "/**\n * USceneSnappingManager is intended to be used as a base class for a Snapping implementation\n * stored in the ContextObjectStore of an InteractiveToolsContext. ITF classes like Tools and Gizmos\n * can then access this object and run snap queries via the various API functions.\n * \n * USceneSnappingManager::Find() can be used to look up a registered USceneSnappingManager, if one is available\n * \n * See UModelingSceneSnappingManager for a sample implementation.\n */" },
		{ "IncludePath", "SceneQueries/SceneSnappingManager.h" },
		{ "ModuleRelativePath", "Public/SceneQueries/SceneSnappingManager.h" },
		{ "ToolTip", "USceneSnappingManager is intended to be used as a base class for a Snapping implementation\nstored in the ContextObjectStore of an InteractiveToolsContext. ITF classes like Tools and Gizmos\ncan then access this object and run snap queries via the various API functions.\n\nUSceneSnappingManager::Find() can be used to look up a registered USceneSnappingManager, if one is available\n\nSee UModelingSceneSnappingManager for a sample implementation." },
	};
#endif // WITH_METADATA

// ********** Begin Class USceneSnappingManager constinit property declarations ********************
// ********** End Class USceneSnappingManager constinit property declarations **********************
	static UObject* (*const DependentSingletons[])();
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USceneSnappingManager>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_USceneSnappingManager_Statics
UObject* (*const Z_Construct_UClass_USceneSnappingManager_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UObject,
	(UObject* (*)())Z_Construct_UPackage__Script_InteractiveToolsFramework,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_USceneSnappingManager_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_USceneSnappingManager_Statics::ClassParams = {
	&USceneSnappingManager::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	nullptr,
	nullptr,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	0,
	0,
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_USceneSnappingManager_Statics::Class_MetaDataParams), Z_Construct_UClass_USceneSnappingManager_Statics::Class_MetaDataParams)
};
void USceneSnappingManager::StaticRegisterNativesUSceneSnappingManager()
{
}
UClass* Z_Construct_UClass_USceneSnappingManager()
{
	if (!Z_Registration_Info_UClass_USceneSnappingManager.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_USceneSnappingManager.OuterSingleton, Z_Construct_UClass_USceneSnappingManager_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_USceneSnappingManager.OuterSingleton;
}
USceneSnappingManager::USceneSnappingManager(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, USceneSnappingManager);
USceneSnappingManager::~USceneSnappingManager() {}
// ********** End Class USceneSnappingManager ******************************************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics
{
	static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
		{ ESceneSnapQueryType_StaticEnum, TEXT("ESceneSnapQueryType"), &Z_Registration_Info_UEnum_ESceneSnapQueryType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 3311217346U) },
		{ ESceneSnapQueryTargetType_StaticEnum, TEXT("ESceneSnapQueryTargetType"), &Z_Registration_Info_UEnum_ESceneSnapQueryTargetType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1286687907U) },
		{ ESceneSnapQueryTargetResult_StaticEnum, TEXT("ESceneSnapQueryTargetResult"), &Z_Registration_Info_UEnum_ESceneSnapQueryTargetResult, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 633625797U) },
	};
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_USceneSnappingManager, USceneSnappingManager::StaticClass, TEXT("USceneSnappingManager"), &Z_Registration_Info_UClass_USceneSnappingManager, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(USceneSnappingManager), 4257900963U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_3760201277{
	TEXT("/Script/InteractiveToolsFramework"),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics::ClassInfo),
	nullptr, 0,
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_InteractiveToolsFramework_Public_SceneQueries_SceneSnappingManager_h__Script_InteractiveToolsFramework_Statics::EnumInfo),
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS