// 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 "SimplygonUObjects/Public/SimplygonUE4UI.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeSimplygonUE4UI() {}
// Cross Module References
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType();
	UPackage* Z_Construct_UPackage__Script_SimplygonUObjects();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EFillMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EDitherType();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EBillboardMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EHoleFilling();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics();
	SIMPLYGONUOBJECTS_API UEnum* Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FSimplygonPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FMappingImageSettings();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonMaterialCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FFlipbookPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FFlipbookSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FAggregationPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FAggregationSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FVisibilitySettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FGeometryCullingSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FVertexWeightSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FRemeshingPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FRemeshingSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FBoneSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FReductionPipelineSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FReductionSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FRepairSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FNormalCalculationSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FVertexColorCasterSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FGeometryDataCasterSettings();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector4();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FDisplacementCasterSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FNormalCasterSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FOpacityCasterSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FColorCasterSettings();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FFoliageSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FInputMaterialSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FOutputMaterialSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FChartAggregatorSettings();
	SIMPLYGONUOBJECTS_API UScriptStruct* Z_Construct_UScriptStruct_FParameterizerSettings();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonPipeline_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonPipeline();
	COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonMaterialCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_UReductionPipeline_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_UReductionPipeline();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_URemeshingPipeline_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_URemeshingPipeline();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_UAggregationPipeline_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_UAggregationPipeline();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonColorCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonColorCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonOpacityCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonOpacityCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonNormalCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonNormalCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonDisplacementCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonDisplacementCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonAmbientOcclusionCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonAmbientOcclusionCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonGeometryDataCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonGeometryDataCaster();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonVertexColorCaster_NoRegister();
	SIMPLYGONUOBJECTS_API UClass* Z_Construct_UClass_USimplygonVertexColorCaster();
// End Cross Module References
	static UEnum* EGeometryDataFieldType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EGeometryDataFieldType"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EGeometryDataFieldType>()
	{
		return EGeometryDataFieldType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EGeometryDataFieldType(EGeometryDataFieldType_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EGeometryDataFieldType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType_Hash() { return 2650187987U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EGeometryDataFieldType"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EGeometryDataFieldType::Coords", (int64)EGeometryDataFieldType::Coords },
				{ "EGeometryDataFieldType::TexCoords", (int64)EGeometryDataFieldType::TexCoords },
				{ "EGeometryDataFieldType::Normals", (int64)EGeometryDataFieldType::Normals },
				{ "EGeometryDataFieldType::Tangents", (int64)EGeometryDataFieldType::Tangents },
				{ "EGeometryDataFieldType::Bitangents", (int64)EGeometryDataFieldType::Bitangents },
				{ "EGeometryDataFieldType::Colors", (int64)EGeometryDataFieldType::Colors },
				{ "EGeometryDataFieldType::TriangleIds", (int64)EGeometryDataFieldType::TriangleIds },
				{ "EGeometryDataFieldType::MaterialIds", (int64)EGeometryDataFieldType::MaterialIds },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Bitangents.Comment", "/**\n      * @brief Per-corner vertex bitangent data, xyz values (3 items per tuple)\n      */" },
				{ "Bitangents.Name", "EGeometryDataFieldType::Bitangents" },
				{ "Bitangents.ToolTip", "@brief Per-corner vertex bitangent data, xyz values (3 items per tuple)" },
				{ "BlueprintType", "true" },
				{ "Colors.Comment", "/**\n      * @brief Per-corner vertex color data, rgba values (4 items per tuple)\n      */" },
				{ "Colors.Name", "EGeometryDataFieldType::Colors" },
				{ "Colors.ToolTip", "@brief Per-corner vertex color data, rgba values (4 items per tuple)" },
				{ "Comment", "/**\n * @brief The GeometryDataFieldType setting, which specifies what field type to cast in the GeometryDataCaster.\n */" },
				{ "Coords.Comment", "/**\n      * @brief Per-vertex coordinate data, xyz values (3 items per tuple)\n      */" },
				{ "Coords.Name", "EGeometryDataFieldType::Coords" },
				{ "Coords.ToolTip", "@brief Per-vertex coordinate data, xyz values (3 items per tuple)" },
				{ "MaterialIds.Comment", "/**\n      * @brief Per-triangle material ids, id values, not interpolated. (1 item per tuple)\n      */" },
				{ "MaterialIds.Name", "EGeometryDataFieldType::MaterialIds" },
				{ "MaterialIds.ToolTip", "@brief Per-triangle material ids, id values, not interpolated. (1 item per tuple)" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Normals.Comment", "/**\n      * @brief Per-corner vertex normals data, xyz values (3 items per tuple)\n      */" },
				{ "Normals.Name", "EGeometryDataFieldType::Normals" },
				{ "Normals.ToolTip", "@brief Per-corner vertex normals data, xyz values (3 items per tuple)" },
				{ "Tangents.Comment", "/**\n      * @brief Per-corner vertex tangent data, xyz values (3 items per tuple)\n      */" },
				{ "Tangents.Name", "EGeometryDataFieldType::Tangents" },
				{ "Tangents.ToolTip", "@brief Per-corner vertex tangent data, xyz values (3 items per tuple)" },
				{ "TexCoords.Comment", "/**\n      * @brief Per-corner texture coords data, uv values (2 items per tuple)\n      */" },
				{ "TexCoords.Name", "EGeometryDataFieldType::TexCoords" },
				{ "TexCoords.ToolTip", "@brief Per-corner texture coords data, uv values (2 items per tuple)" },
				{ "ToolTip", "@brief The GeometryDataFieldType setting, which specifies what field type to cast in the GeometryDataCaster." },
				{ "TriangleIds.Comment", "/**\n      * @brief Per-triangle triangle ids, id values, not interpolated. (1 item per tuple)\n      */" },
				{ "TriangleIds.Name", "EGeometryDataFieldType::TriangleIds" },
				{ "TriangleIds.ToolTip", "@brief Per-triangle triangle ids, id values, not interpolated. (1 item per tuple)" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EGeometryDataFieldType",
				"EGeometryDataFieldType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EOutputPixelFormat_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EOutputPixelFormat"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EOutputPixelFormat>()
	{
		return EOutputPixelFormat_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOutputPixelFormat(EOutputPixelFormat_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EOutputPixelFormat"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat_Hash() { return 152433440U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOutputPixelFormat"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EOutputPixelFormat::R8G8B8A8", (int64)EOutputPixelFormat::R8G8B8A8 },
				{ "EOutputPixelFormat::R8G8B8", (int64)EOutputPixelFormat::R8G8B8 },
				{ "EOutputPixelFormat::R8", (int64)EOutputPixelFormat::R8 },
				{ "EOutputPixelFormat::R16G16B16A16", (int64)EOutputPixelFormat::R16G16B16A16 },
				{ "EOutputPixelFormat::R16G16B16", (int64)EOutputPixelFormat::R16G16B16 },
				{ "EOutputPixelFormat::R16", (int64)EOutputPixelFormat::R16 },
				{ "EOutputPixelFormat::R32G32B32A32F", (int64)EOutputPixelFormat::R32G32B32A32F },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The output pixel format\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "R16.Comment", "/**\n      * @brief R color channel with 16 bit depth per color channel\n      */" },
				{ "R16.Name", "EOutputPixelFormat::R16" },
				{ "R16.ToolTip", "@brief R color channel with 16 bit depth per color channel" },
				{ "R16G16B16.Comment", "/**\n      * @brief RGB color channels with 16 bit depth per color channel\n      */" },
				{ "R16G16B16.Name", "EOutputPixelFormat::R16G16B16" },
				{ "R16G16B16.ToolTip", "@brief RGB color channels with 16 bit depth per color channel" },
				{ "R16G16B16A16.Comment", "/**\n      * @brief RGBA color channels with 16 bit depth per color channel\n      */" },
				{ "R16G16B16A16.Name", "EOutputPixelFormat::R16G16B16A16" },
				{ "R16G16B16A16.ToolTip", "@brief RGBA color channels with 16 bit depth per color channel" },
				{ "R32G32B32A32F.Comment", "/**\n      * @brief RGBA color channels with 32 bit depth floating point per color channel\n      */" },
				{ "R32G32B32A32F.Name", "EOutputPixelFormat::R32G32B32A32F" },
				{ "R32G32B32A32F.ToolTip", "@brief RGBA color channels with 32 bit depth floating point per color channel" },
				{ "R8.Comment", "/**\n      * @brief R color channel with 8 bit depth per color channel\n      */" },
				{ "R8.Name", "EOutputPixelFormat::R8" },
				{ "R8.ToolTip", "@brief R color channel with 8 bit depth per color channel" },
				{ "R8G8B8.Comment", "/**\n      * @brief RGB color channels with 8 bit depth per color channel\n      */" },
				{ "R8G8B8.Name", "EOutputPixelFormat::R8G8B8" },
				{ "R8G8B8.ToolTip", "@brief RGB color channels with 8 bit depth per color channel" },
				{ "R8G8B8A8.Comment", "/**\n      * @brief RGBA color channels with 8 bit depth per color channel\n      */" },
				{ "R8G8B8A8.Name", "EOutputPixelFormat::R8G8B8A8" },
				{ "R8G8B8A8.ToolTip", "@brief RGBA color channels with 8 bit depth per color channel" },
				{ "ToolTip", "@brief The output pixel format" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EOutputPixelFormat",
				"EOutputPixelFormat",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EOutputOpacityType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EOutputOpacityType"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EOutputOpacityType>()
	{
		return EOutputOpacityType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOutputOpacityType(EOutputOpacityType_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EOutputOpacityType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType_Hash() { return 2433075875U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOutputOpacityType"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EOutputOpacityType::Opacity", (int64)EOutputOpacityType::Opacity },
				{ "EOutputOpacityType::Transparency", (int64)EOutputOpacityType::Transparency },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency'\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Opacity.Comment", "/**\n      * @brief The level of transparency is defined from 0.0->1.0, where 0.0 is fully transparent and 1.0 is fully opaque.\n      */" },
				{ "Opacity.Name", "EOutputOpacityType::Opacity" },
				{ "Opacity.ToolTip", "@brief The level of transparency is defined from 0.0->1.0, where 0.0 is fully transparent and 1.0 is fully opaque." },
				{ "ToolTip", "@brief The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency'" },
				{ "Transparency.Comment", "/**\n      * @brief The level of transparency is defined from 1.0->0.0, where 1.0 is fully transparent and 0.0 is fully opaque.\n      */" },
				{ "Transparency.Name", "EOutputOpacityType::Transparency" },
				{ "Transparency.ToolTip", "@brief The level of transparency is defined from 1.0->0.0, where 1.0 is fully transparent and 0.0 is fully opaque." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EOutputOpacityType",
				"EOutputOpacityType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EOutputDDSCompressionType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EOutputDDSCompressionType"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EOutputDDSCompressionType>()
	{
		return EOutputDDSCompressionType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOutputDDSCompressionType(EOutputDDSCompressionType_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EOutputDDSCompressionType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType_Hash() { return 3531585560U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOutputDDSCompressionType"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EOutputDDSCompressionType::NoCompression", (int64)EOutputDDSCompressionType::NoCompression },
				{ "EOutputDDSCompressionType::BC1", (int64)EOutputDDSCompressionType::BC1 },
				{ "EOutputDDSCompressionType::BC2", (int64)EOutputDDSCompressionType::BC2 },
				{ "EOutputDDSCompressionType::BC3", (int64)EOutputDDSCompressionType::BC3 },
				{ "EOutputDDSCompressionType::BC4", (int64)EOutputDDSCompressionType::BC4 },
				{ "EOutputDDSCompressionType::BC5", (int64)EOutputDDSCompressionType::BC5 },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BC1.Comment", "/**\n      * @brief \n      */" },
				{ "BC1.Name", "EOutputDDSCompressionType::BC1" },
				{ "BC1.ToolTip", "@brief" },
				{ "BC2.Comment", "/**\n      * @brief \n      */" },
				{ "BC2.Name", "EOutputDDSCompressionType::BC2" },
				{ "BC2.ToolTip", "@brief" },
				{ "BC3.Comment", "/**\n      * @brief \n      */" },
				{ "BC3.Name", "EOutputDDSCompressionType::BC3" },
				{ "BC3.ToolTip", "@brief" },
				{ "BC4.Comment", "/**\n      * @brief \n      */" },
				{ "BC4.Name", "EOutputDDSCompressionType::BC4" },
				{ "BC4.ToolTip", "@brief" },
				{ "BC5.Comment", "/**\n      * @brief \n      */" },
				{ "BC5.Name", "EOutputDDSCompressionType::BC5" },
				{ "BC5.ToolTip", "@brief" },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief DDS compression if output format is DDS.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "NoCompression.Comment", "/**\n      * @brief \n      */" },
				{ "NoCompression.Name", "EOutputDDSCompressionType::NoCompression" },
				{ "NoCompression.ToolTip", "@brief" },
				{ "ToolTip", "@brief DDS compression if output format is DDS." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EOutputDDSCompressionType",
				"EOutputDDSCompressionType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EOutputImageFileFormat_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EOutputImageFileFormat"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EOutputImageFileFormat>()
	{
		return EOutputImageFileFormat_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOutputImageFileFormat(EOutputImageFileFormat_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EOutputImageFileFormat"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat_Hash() { return 2005941515U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOutputImageFileFormat"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EOutputImageFileFormat::BMP", (int64)EOutputImageFileFormat::BMP },
				{ "EOutputImageFileFormat::DDS", (int64)EOutputImageFileFormat::DDS },
				{ "EOutputImageFileFormat::JPEG", (int64)EOutputImageFileFormat::JPEG },
				{ "EOutputImageFileFormat::PNG", (int64)EOutputImageFileFormat::PNG },
				{ "EOutputImageFileFormat::TGA", (int64)EOutputImageFileFormat::TGA },
				{ "EOutputImageFileFormat::TIFF", (int64)EOutputImageFileFormat::TIFF },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "BMP.Comment", "/**\n      * @brief \n      */" },
				{ "BMP.Name", "EOutputImageFileFormat::BMP" },
				{ "BMP.ToolTip", "@brief" },
				{ "Comment", "/**\n * @brief File format for output texture.\n */" },
				{ "DDS.Comment", "/**\n      * @brief \n      */" },
				{ "DDS.Name", "EOutputImageFileFormat::DDS" },
				{ "DDS.ToolTip", "@brief" },
				{ "JPEG.Comment", "/**\n      * @brief \n      */" },
				{ "JPEG.Name", "EOutputImageFileFormat::JPEG" },
				{ "JPEG.ToolTip", "@brief" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "PNG.Comment", "/**\n      * @brief \n      */" },
				{ "PNG.Name", "EOutputImageFileFormat::PNG" },
				{ "PNG.ToolTip", "@brief" },
				{ "TGA.Comment", "/**\n      * @brief \n      */" },
				{ "TGA.Name", "EOutputImageFileFormat::TGA" },
				{ "TGA.ToolTip", "@brief" },
				{ "TIFF.Comment", "/**\n      * @brief \n      */" },
				{ "TIFF.Name", "EOutputImageFileFormat::TIFF" },
				{ "TIFF.ToolTip", "@brief" },
				{ "ToolTip", "@brief File format for output texture." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EOutputImageFileFormat",
				"EOutputImageFileFormat",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFillMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EFillMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EFillMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EFillMode>()
	{
		return EFillMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFillMode(EFillMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EFillMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EFillMode_Hash() { return 1946904454U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EFillMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFillMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EFillMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFillMode::Interpolate", (int64)EFillMode::Interpolate },
				{ "EFillMode::NearestNeighbor", (int64)EFillMode::NearestNeighbor },
				{ "EFillMode::NoFill", (int64)EFillMode::NoFill },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation.\n */" },
				{ "Interpolate.Comment", "/**\n      * @brief linearly interpolate the closest samples\n      */" },
				{ "Interpolate.Name", "EFillMode::Interpolate" },
				{ "Interpolate.ToolTip", "@brief linearly interpolate the closest samples" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "NearestNeighbor.Comment", "/**\n      * @brief use the closest available pixel value without interpolation\n      */" },
				{ "NearestNeighbor.Name", "EFillMode::NearestNeighbor" },
				{ "NearestNeighbor.ToolTip", "@brief use the closest available pixel value without interpolation" },
				{ "NoFill.Comment", "/**\n      * @brief Do not fill remaining pixels\n      */" },
				{ "NoFill.Name", "EFillMode::NoFill" },
				{ "NoFill.ToolTip", "@brief Do not fill remaining pixels" },
				{ "ToolTip", "@brief The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EFillMode",
				"EFillMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EDitherType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EDitherType, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EDitherType"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EDitherType>()
	{
		return EDitherType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EDitherType(EDitherType_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EDitherType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EDitherType_Hash() { return 2131643661U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EDitherType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EDitherType"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EDitherType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EDitherType::NoDither", (int64)EDitherType::NoDither },
				{ "EDitherType::FloydSteinberg", (int64)EDitherType::FloydSteinberg },
				{ "EDitherType::JarvisJudiceNinke", (int64)EDitherType::JarvisJudiceNinke },
				{ "EDitherType::Sierra", (int64)EDitherType::Sierra },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The type of dithering to use when creating the output object.\n */" },
				{ "FloydSteinberg.Comment", "/**\n      * @brief Use Floyd-Steinberg dithering\n      */" },
				{ "FloydSteinberg.Name", "EDitherType::FloydSteinberg" },
				{ "FloydSteinberg.ToolTip", "@brief Use Floyd-Steinberg dithering" },
				{ "JarvisJudiceNinke.Comment", "/**\n      * @brief Use Jarvis, Judice, and Ninke dithering\n      */" },
				{ "JarvisJudiceNinke.Name", "EDitherType::JarvisJudiceNinke" },
				{ "JarvisJudiceNinke.ToolTip", "@brief Use Jarvis, Judice, and Ninke dithering" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "NoDither.Comment", "/**\n      * @brief Use no dithering\n      */" },
				{ "NoDither.Name", "EDitherType::NoDither" },
				{ "NoDither.ToolTip", "@brief Use no dithering" },
				{ "Sierra.Comment", "/**\n      * @brief Use Sierra-3 (three row) dithering\n      */" },
				{ "Sierra.Name", "EDitherType::Sierra" },
				{ "Sierra.ToolTip", "@brief Use Sierra-3 (three row) dithering" },
				{ "ToolTip", "@brief The type of dithering to use when creating the output object." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EDitherType",
				"EDitherType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EOpacityChannelComponent_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EOpacityChannelComponent"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EOpacityChannelComponent>()
	{
		return EOpacityChannelComponent_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOpacityChannelComponent(EOpacityChannelComponent_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EOpacityChannelComponent"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent_Hash() { return 2113706240U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOpacityChannelComponent"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EOpacityChannelComponent::Red", (int64)EOpacityChannelComponent::Red },
				{ "EOpacityChannelComponent::Green", (int64)EOpacityChannelComponent::Green },
				{ "EOpacityChannelComponent::Blue", (int64)EOpacityChannelComponent::Blue },
				{ "EOpacityChannelComponent::Alpha", (int64)EOpacityChannelComponent::Alpha },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Alpha.Comment", "/**\n      * @brief Alpha color component\n      */" },
				{ "Alpha.Name", "EOpacityChannelComponent::Alpha" },
				{ "Alpha.ToolTip", "@brief Alpha color component" },
				{ "Blue.Comment", "/**\n      * @brief Blue color component\n      */" },
				{ "Blue.Name", "EOpacityChannelComponent::Blue" },
				{ "Blue.ToolTip", "@brief Blue color component" },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The component in the opacity channel to use as opacity value.\n */" },
				{ "Green.Comment", "/**\n      * @brief Green color component\n      */" },
				{ "Green.Name", "EOpacityChannelComponent::Green" },
				{ "Green.ToolTip", "@brief Green color component" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Red.Comment", "/**\n      * @brief Red color component\n      */" },
				{ "Red.Name", "EOpacityChannelComponent::Red" },
				{ "Red.ToolTip", "@brief Red color component" },
				{ "ToolTip", "@brief The component in the opacity channel to use as opacity value." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EOpacityChannelComponent",
				"EOpacityChannelComponent",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EBillboardMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EBillboardMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EBillboardMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EBillboardMode>()
	{
		return EBillboardMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBillboardMode(EBillboardMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EBillboardMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EBillboardMode_Hash() { return 1609528059U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EBillboardMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBillboardMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EBillboardMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EBillboardMode::OuterShell", (int64)EBillboardMode::OuterShell },
				{ "EBillboardMode::Foliage", (int64)EBillboardMode::Foliage },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief Specifies how the impostors should be mapped to the scene.\n */" },
				{ "Foliage.Comment", "/**\n      * @brief The impostors fit to the entire volume of the scene. Better for chaotic meshes that has lots of geometry within its volume, like vegetation.\n      */" },
				{ "Foliage.Name", "EBillboardMode::Foliage" },
				{ "Foliage.ToolTip", "@brief The impostors fit to the entire volume of the scene. Better for chaotic meshes that has lots of geometry within its volume, like vegetation." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "OuterShell.Comment", "/**\n      * @brief Prioritize fitting the impostors to the exterior hull of the scene. Better for solid/opaque meshes like buildings/vehicles.\n      */" },
				{ "OuterShell.Name", "EBillboardMode::OuterShell" },
				{ "OuterShell.ToolTip", "@brief Prioritize fitting the impostors to the exterior hull of the scene. Better for solid/opaque meshes like buildings/vehicles." },
				{ "ToolTip", "@brief Specifies how the impostors should be mapped to the scene." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EBillboardMode",
				"EBillboardMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ESurfaceTransferMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ESurfaceTransferMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<ESurfaceTransferMode>()
	{
		return ESurfaceTransferMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ESurfaceTransferMode(ESurfaceTransferMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("ESurfaceTransferMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode_Hash() { return 4128988680U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ESurfaceTransferMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ESurfaceTransferMode::Fast", (int64)ESurfaceTransferMode::Fast },
				{ "ESurfaceTransferMode::Accurate", (int64)ESurfaceTransferMode::Accurate },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Accurate.Comment", "/**\n      * @brief Slower and more accurate.\n      */" },
				{ "Accurate.Name", "ESurfaceTransferMode::Accurate" },
				{ "Accurate.ToolTip", "@brief Slower and more accurate." },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The surface transfer mode.\n */" },
				{ "Fast.Comment", "/**\n      * @brief Faster but with less precise calculations.\n      */" },
				{ "Fast.Name", "ESurfaceTransferMode::Fast" },
				{ "Fast.ToolTip", "@brief Faster but with less precise calculations." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief The surface transfer mode." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"ESurfaceTransferMode",
				"ESurfaceTransferMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ERemeshingMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ERemeshingMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<ERemeshingMode>()
	{
		return ERemeshingMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ERemeshingMode(ERemeshingMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("ERemeshingMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode_Hash() { return 3933115611U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ERemeshingMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ERemeshingMode::Outside", (int64)ERemeshingMode::Outside },
				{ "ERemeshingMode::Inside", (int64)ERemeshingMode::Inside },
				{ "ERemeshingMode::Manual", (int64)ERemeshingMode::Manual },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The remeshing mode, options are Outside, Inside and Manual. RemeshingMode defines if the remeshing processor remeshes the outside or the inside of the input geometry. Manual needs the user to define a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition. Hole filling only works with the mode Outside.\n */" },
				{ "Inside.Comment", "/**\n      * @brief Automatically remeshes the largest inside space of the geometry\n      */" },
				{ "Inside.Name", "ERemeshingMode::Inside" },
				{ "Inside.ToolTip", "@brief Automatically remeshes the largest inside space of the geometry" },
				{ "Manual.Comment", "/**\n      * @brief User defines a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition\n      */" },
				{ "Manual.Name", "ERemeshingMode::Manual" },
				{ "Manual.ToolTip", "@brief User defines a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Outside.Comment", "/**\n      * @brief Automatically remeshes the outside of the geometry.\n      */" },
				{ "Outside.Name", "ERemeshingMode::Outside" },
				{ "Outside.ToolTip", "@brief Automatically remeshes the outside of the geometry." },
				{ "ToolTip", "@brief The remeshing mode, options are Outside, Inside and Manual. RemeshingMode defines if the remeshing processor remeshes the outside or the inside of the input geometry. Manual needs the user to define a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition. Hole filling only works with the mode Outside." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"ERemeshingMode",
				"ERemeshingMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EHoleFilling_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EHoleFilling, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EHoleFilling"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EHoleFilling>()
	{
		return EHoleFilling_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EHoleFilling(EHoleFilling_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EHoleFilling"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EHoleFilling_Hash() { return 1521753709U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EHoleFilling()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EHoleFilling"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EHoleFilling_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EHoleFilling::Disabled", (int64)EHoleFilling::Disabled },
				{ "EHoleFilling::Low", (int64)EHoleFilling::Low },
				{ "EHoleFilling::Medium", (int64)EHoleFilling::Medium },
				{ "EHoleFilling::High", (int64)EHoleFilling::High },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief HoleFilling defines how aggressively the remesher will fill holes and cavities. What this does is to measure the volume and hole opening sizes of concavities in the input geometry and fill them in in the remeshing if the concavity is large enough with a small enough opening. This removes a lot of unnecessary geometry and is recommended to be kept at it's default rather than turning it off, it will in the vast majority of cases have a positive effect on the result.\n */" },
				{ "Disabled.Comment", "/**\n      * @brief No hole filling.\n      */" },
				{ "Disabled.Name", "EHoleFilling::Disabled" },
				{ "Disabled.ToolTip", "@brief No hole filling." },
				{ "High.Comment", "/**\n      * @brief Aggressive hole filling.\n      */" },
				{ "High.Name", "EHoleFilling::High" },
				{ "High.ToolTip", "@brief Aggressive hole filling." },
				{ "Low.Comment", "/**\n      * @brief Minor hole filling.\n      */" },
				{ "Low.Name", "EHoleFilling::Low" },
				{ "Low.ToolTip", "@brief Minor hole filling." },
				{ "Medium.Comment", "/**\n      * @brief Moderate amounts of hole filling.\n      */" },
				{ "Medium.Name", "EHoleFilling::Medium" },
				{ "Medium.ToolTip", "@brief Moderate amounts of hole filling." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief HoleFilling defines how aggressively the remesher will fill holes and cavities. What this does is to measure the volume and hole opening sizes of concavities in the input geometry and fill them in in the remeshing if the concavity is large enough with a small enough opening. This removes a lot of unnecessary geometry and is recommended to be kept at it's default rather than turning it off, it will in the vast majority of cases have a positive effect on the result." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EHoleFilling",
				"EHoleFilling",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ESurfaceAreaScale_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ESurfaceAreaScale"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<ESurfaceAreaScale>()
	{
		return ESurfaceAreaScale_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ESurfaceAreaScale(ESurfaceAreaScale_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("ESurfaceAreaScale"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale_Hash() { return 659886368U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ESurfaceAreaScale"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ESurfaceAreaScale::LargestInstance", (int64)ESurfaceAreaScale::LargestInstance },
				{ "ESurfaceAreaScale::SmallestInstance", (int64)ESurfaceAreaScale::SmallestInstance },
				{ "ESurfaceAreaScale::Average", (int64)ESurfaceAreaScale::Average },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Average.Comment", "/**\n      * @brief If multiple UV charts overlap and have the same material, the average of all the instances determine the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false.\n      */" },
				{ "Average.Name", "ESurfaceAreaScale::Average" },
				{ "Average.ToolTip", "@brief If multiple UV charts overlap and have the same material, the average of all the instances determine the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false." },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief If multiple UV charts overlap and have the same material, SurfaceAreaScale specifies which of those instances determines the the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false.\n */" },
				{ "LargestInstance.Comment", "/**\n      * @brief If multiple UV charts overlap and have the same material, the largest instance determines the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false.\n      */" },
				{ "LargestInstance.Name", "ESurfaceAreaScale::LargestInstance" },
				{ "LargestInstance.ToolTip", "@brief If multiple UV charts overlap and have the same material, the largest instance determines the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "SmallestInstance.Comment", "/**\n      * @brief If multiple UV charts overlap and have the same material, the smallest instance determines the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false.\n      */" },
				{ "SmallestInstance.Name", "ESurfaceAreaScale::SmallestInstance" },
				{ "SmallestInstance.ToolTip", "@brief If multiple UV charts overlap and have the same material, the smallest instance determines the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false." },
				{ "ToolTip", "@brief If multiple UV charts overlap and have the same material, SurfaceAreaScale specifies which of those instances determines the the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"ESurfaceAreaScale",
				"ESurfaceAreaScale",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EChartAggregatorMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EChartAggregatorMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EChartAggregatorMode>()
	{
		return EChartAggregatorMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EChartAggregatorMode(EChartAggregatorMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EChartAggregatorMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode_Hash() { return 678574277U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EChartAggregatorMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EChartAggregatorMode::TextureSizeProportions", (int64)EChartAggregatorMode::TextureSizeProportions },
				{ "EChartAggregatorMode::SurfaceArea", (int64)EChartAggregatorMode::SurfaceArea },
				{ "EChartAggregatorMode::OriginalPixelDensity", (int64)EChartAggregatorMode::OriginalPixelDensity },
				{ "EChartAggregatorMode::UVSizeProportions", (int64)EChartAggregatorMode::UVSizeProportions },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "OriginalPixelDensity.Comment", "/**\n      * @brief The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size.\n      */" },
				{ "OriginalPixelDensity.Name", "EChartAggregatorMode::OriginalPixelDensity" },
				{ "OriginalPixelDensity.ToolTip", "@brief The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size." },
				{ "SurfaceArea.Comment", "/**\n      * @brief Aggregated UV charts will have their size set based on its actual geometrical size.\n      */" },
				{ "SurfaceArea.Name", "EChartAggregatorMode::SurfaceArea" },
				{ "SurfaceArea.ToolTip", "@brief Aggregated UV charts will have their size set based on its actual geometrical size." },
				{ "TextureSizeProportions.Comment", "/**\n      * @brief Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps.\n      */" },
				{ "TextureSizeProportions.Name", "EChartAggregatorMode::TextureSizeProportions" },
				{ "TextureSizeProportions.ToolTip", "@brief Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps." },
				{ "ToolTip", "@brief Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in." },
				{ "UVSizeProportions.Comment", "/**\n      * @brief Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in.\n      */" },
				{ "UVSizeProportions.Name", "EChartAggregatorMode::UVSizeProportions" },
				{ "UVSizeProportions.ToolTip", "@brief Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EChartAggregatorMode",
				"EChartAggregatorMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ETexCoordGeneratorType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ETexCoordGeneratorType"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<ETexCoordGeneratorType>()
	{
		return ETexCoordGeneratorType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ETexCoordGeneratorType(ETexCoordGeneratorType_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("ETexCoordGeneratorType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType_Hash() { return 119468671U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ETexCoordGeneratorType"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ETexCoordGeneratorType::Parameterizer", (int64)ETexCoordGeneratorType::Parameterizer },
				{ "ETexCoordGeneratorType::ChartAggregator", (int64)ETexCoordGeneratorType::ChartAggregator },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ChartAggregator.Comment", "/**\n      * @brief Texture coordinates are generated based on the original texture coordinates.\n      */" },
				{ "ChartAggregator.Name", "ETexCoordGeneratorType::ChartAggregator" },
				{ "ChartAggregator.ToolTip", "@brief Texture coordinates are generated based on the original texture coordinates." },
				{ "Comment", "/**\n * @brief Determines which method to use when generating the texture coordinates. Parameterizer generate from scratch based on the geometry. ChartAggregator generate based on the original texture coordinates.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Parameterizer.Comment", "/**\n      * @brief Texture coordinates are generated from scratch based on the geometry.\n      */" },
				{ "Parameterizer.Name", "ETexCoordGeneratorType::Parameterizer" },
				{ "Parameterizer.ToolTip", "@brief Texture coordinates are generated from scratch based on the geometry." },
				{ "ToolTip", "@brief Determines which method to use when generating the texture coordinates. Parameterizer generate from scratch based on the geometry. ChartAggregator generate based on the original texture coordinates." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"ETexCoordGeneratorType",
				"ETexCoordGeneratorType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EWeightsFromColorMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EWeightsFromColorMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EWeightsFromColorMode>()
	{
		return EWeightsFromColorMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EWeightsFromColorMode(EWeightsFromColorMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EWeightsFromColorMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode_Hash() { return 3017256610U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EWeightsFromColorMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EWeightsFromColorMode::Standard", (int64)EWeightsFromColorMode::Standard },
				{ "EWeightsFromColorMode::High", (int64)EWeightsFromColorMode::High },
				{ "EWeightsFromColorMode::Low", (int64)EWeightsFromColorMode::Low },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief If converting vertex colors to weights, this setting along with WeightsFromColorMultiplier controls how to map the RGBA intensity between 0-1 to weights. Standard mode maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]. High mode maps color intensity [0-1] to vertex weight [1 - Multiplier]. Low mode maps color intensity [0-1] to vertex weight [1/Multiplier - 1].\n */" },
				{ "High.Comment", "/**\n      * @brief Maps color intensity [0-1] to vertex weight [1 - Multiplier]\n      */" },
				{ "High.Name", "EWeightsFromColorMode::High" },
				{ "High.ToolTip", "@brief Maps color intensity [0-1] to vertex weight [1 - Multiplier]" },
				{ "Low.Comment", "/**\n      * @brief Maps color intensity [0-1] to vertex weight [1/Multiplier - 1]\n      */" },
				{ "Low.Name", "EWeightsFromColorMode::Low" },
				{ "Low.ToolTip", "@brief Maps color intensity [0-1] to vertex weight [1/Multiplier - 1]" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Standard.Comment", "/**\n      * @brief Maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]\n      */" },
				{ "Standard.Name", "EWeightsFromColorMode::Standard" },
				{ "Standard.ToolTip", "@brief Maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]" },
				{ "ToolTip", "@brief If converting vertex colors to weights, this setting along with WeightsFromColorMultiplier controls how to map the RGBA intensity between 0-1 to weights. Standard mode maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]. High mode maps color intensity [0-1] to vertex weight [1 - Multiplier]. Low mode maps color intensity [0-1] to vertex weight [1/Multiplier - 1]." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EWeightsFromColorMode",
				"EWeightsFromColorMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EWeightsFromColorComponent_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EWeightsFromColorComponent"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EWeightsFromColorComponent>()
	{
		return EWeightsFromColorComponent_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EWeightsFromColorComponent(EWeightsFromColorComponent_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EWeightsFromColorComponent"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent_Hash() { return 2858133510U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EWeightsFromColorComponent"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EWeightsFromColorComponent::Red", (int64)EWeightsFromColorComponent::Red },
				{ "EWeightsFromColorComponent::Green", (int64)EWeightsFromColorComponent::Green },
				{ "EWeightsFromColorComponent::Blue", (int64)EWeightsFromColorComponent::Blue },
				{ "EWeightsFromColorComponent::Alpha", (int64)EWeightsFromColorComponent::Alpha },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Alpha.Comment", "/**\n      * @brief Alpha color component\n      */" },
				{ "Alpha.Name", "EWeightsFromColorComponent::Alpha" },
				{ "Alpha.ToolTip", "@brief Alpha color component" },
				{ "Blue.Comment", "/**\n      * @brief Blue color component\n      */" },
				{ "Blue.Name", "EWeightsFromColorComponent::Blue" },
				{ "Blue.ToolTip", "@brief Blue color component" },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief If converting vertex colors to weights, this setting controls which color component is used to create the weights.\n */" },
				{ "Green.Comment", "/**\n      * @brief Green color component\n      */" },
				{ "Green.Name", "EWeightsFromColorComponent::Green" },
				{ "Green.ToolTip", "@brief Green color component" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Red.Comment", "/**\n      * @brief Red color component\n      */" },
				{ "Red.Name", "EWeightsFromColorComponent::Red" },
				{ "Red.ToolTip", "@brief Red color component" },
				{ "ToolTip", "@brief If converting vertex colors to weights, this setting controls which color component is used to create the weights." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EWeightsFromColorComponent",
				"EWeightsFromColorComponent",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EBoneReductionTargetStopCondition_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EBoneReductionTargetStopCondition"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EBoneReductionTargetStopCondition>()
	{
		return EBoneReductionTargetStopCondition_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBoneReductionTargetStopCondition(EBoneReductionTargetStopCondition_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EBoneReductionTargetStopCondition"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition_Hash() { return 3558485217U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBoneReductionTargetStopCondition"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EBoneReductionTargetStopCondition::Any", (int64)EBoneReductionTargetStopCondition::Any },
				{ "EBoneReductionTargetStopCondition::All", (int64)EBoneReductionTargetStopCondition::All },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "All.Comment", "/**\n      * @brief Simplygon will continue processing until all of the reduction targets have been fulfilled.\n      */" },
				{ "All.Name", "EBoneReductionTargetStopCondition::All" },
				{ "All.ToolTip", "@brief Simplygon will continue processing until all of the reduction targets have been fulfilled." },
				{ "Any.Comment", "/**\n      * @brief Simplygon will stop as soon as one of the reduction targets has been fulfilled.\n      */" },
				{ "Any.Name", "EBoneReductionTargetStopCondition::Any" },
				{ "Any.ToolTip", "@brief Simplygon will stop as soon as one of the reduction targets has been fulfilled." },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The stop condition for the bone reducer. Any: the reducer will stop when any single one of the set reduction targets have been reached. All: the reducer will stop when all enabled reduction targets have been set.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief The stop condition for the bone reducer. Any: the reducer will stop when any single one of the set reduction targets have been reached. All: the reducer will stop when all enabled reduction targets have been set." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EBoneReductionTargetStopCondition",
				"EBoneReductionTargetStopCondition",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EComputeVisibilityMode_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EComputeVisibilityMode"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EComputeVisibilityMode>()
	{
		return EComputeVisibilityMode_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EComputeVisibilityMode(EComputeVisibilityMode_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EComputeVisibilityMode"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode_Hash() { return 3879073037U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EComputeVisibilityMode"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EComputeVisibilityMode::DirectX", (int64)EComputeVisibilityMode::DirectX },
				{ "EComputeVisibilityMode::Software", (int64)EComputeVisibilityMode::Software },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief Specifies the renderer type when computing visibility.\n */" },
				{ "DirectX.Comment", "/**\n      * @brief Use DirectX when computing visibility.\n      */" },
				{ "DirectX.Name", "EComputeVisibilityMode::DirectX" },
				{ "DirectX.ToolTip", "@brief Use DirectX when computing visibility." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "Software.Comment", "/**\n      * @brief Use a software renderer when computing visibility.\n      */" },
				{ "Software.Name", "EComputeVisibilityMode::Software" },
				{ "Software.ToolTip", "@brief Use a software renderer when computing visibility." },
				{ "ToolTip", "@brief Specifies the renderer type when computing visibility." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EComputeVisibilityMode",
				"EComputeVisibilityMode",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EDataCreationPreferences_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EDataCreationPreferences"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EDataCreationPreferences>()
	{
		return EDataCreationPreferences_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EDataCreationPreferences(EDataCreationPreferences_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EDataCreationPreferences"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences_Hash() { return 2481713059U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EDataCreationPreferences"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EDataCreationPreferences::OnlyUseOriginalData", (int64)EDataCreationPreferences::OnlyUseOriginalData },
				{ "EDataCreationPreferences::PreferOriginalData", (int64)EDataCreationPreferences::PreferOriginalData },
				{ "EDataCreationPreferences::PreferOptimizedResult", (int64)EDataCreationPreferences::PreferOptimizedResult },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The flag that specifies how big 'freedom' Simplygon has when it comes to altering vertex/triangle data. Allowing more altered data means it will be easier to create good looking LODs, but without altered data it will be easier to keep the memory-usage in the LOD-chain more optimized. Note: When using OnlyUseOriginalData, the geometry being reduced can not have a node transformation matrix other than the identity matrix.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "OnlyUseOriginalData.Comment", "/**\n      * @brief Vertex and Corner data such as coordinates and normals will be completely re-used from the original Scene.\n      */" },
				{ "OnlyUseOriginalData.Name", "EDataCreationPreferences::OnlyUseOriginalData" },
				{ "OnlyUseOriginalData.ToolTip", "@brief Vertex and Corner data such as coordinates and normals will be completely re-used from the original Scene." },
				{ "PreferOptimizedResult.Comment", "/**\n      * @brief Both vertex coordinates and corner normals will be altered to make the optimized Scene look as good as possible.\n      */" },
				{ "PreferOptimizedResult.Name", "EDataCreationPreferences::PreferOptimizedResult" },
				{ "PreferOptimizedResult.ToolTip", "@brief Both vertex coordinates and corner normals will be altered to make the optimized Scene look as good as possible." },
				{ "PreferOriginalData.Comment", "/**\n      * @brief Vertex coordinates will remaining as they were in the original Scene, but corner normals might be changed if Simplygon decided it will look better.\n      */" },
				{ "PreferOriginalData.Name", "EDataCreationPreferences::PreferOriginalData" },
				{ "PreferOriginalData.ToolTip", "@brief Vertex coordinates will remaining as they were in the original Scene, but corner normals might be changed if Simplygon decided it will look better." },
				{ "ToolTip", "@brief The flag that specifies how big 'freedom' Simplygon has when it comes to altering vertex/triangle data. Allowing more altered data means it will be easier to create good looking LODs, but without altered data it will be easier to keep the memory-usage in the LOD-chain more optimized. Note: When using OnlyUseOriginalData, the geometry being reduced can not have a node transformation matrix other than the identity matrix." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EDataCreationPreferences",
				"EDataCreationPreferences",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ESymmetryAxis_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ESymmetryAxis"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<ESymmetryAxis>()
	{
		return ESymmetryAxis_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ESymmetryAxis(ESymmetryAxis_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("ESymmetryAxis"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis_Hash() { return 4138685083U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ESymmetryAxis"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ESymmetryAxis::X", (int64)ESymmetryAxis::X },
				{ "ESymmetryAxis::Y", (int64)ESymmetryAxis::Y },
				{ "ESymmetryAxis::Z", (int64)ESymmetryAxis::Z },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief Set what axis to be used for symmetry calculations.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief Set what axis to be used for symmetry calculations." },
				{ "X.Comment", "/**\n      * @brief X axis.\n      */" },
				{ "X.Name", "ESymmetryAxis::X" },
				{ "X.ToolTip", "@brief X axis." },
				{ "Y.Comment", "/**\n      * @brief Z axis.\n      */" },
				{ "Y.Name", "ESymmetryAxis::Y" },
				{ "Y.ToolTip", "@brief Z axis." },
				{ "Z.Comment", "/**\n      * @brief Z axis.\n      */" },
				{ "Z.Name", "ESymmetryAxis::Z" },
				{ "Z.ToolTip", "@brief Z axis." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"ESymmetryAxis",
				"ESymmetryAxis",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EReductionHeuristics_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EReductionHeuristics"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EReductionHeuristics>()
	{
		return EReductionHeuristics_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EReductionHeuristics(EReductionHeuristics_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EReductionHeuristics"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics_Hash() { return 208358082U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EReductionHeuristics"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EReductionHeuristics::Fast", (int64)EReductionHeuristics::Fast },
				{ "EReductionHeuristics::Consistent", (int64)EReductionHeuristics::Consistent },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The flag that decides how precise the reducer will be during the mesh reduction. Fast -> Reducer will be faster, but onscreensize and trianglecount will not match perfectly.  Consistent -> Reducer will be slower, but onscreensize and trianglecount will consistently give matching results.\n */" },
				{ "Consistent.Comment", "/**\n      * @brief Slower but more accurate.\n      */" },
				{ "Consistent.Name", "EReductionHeuristics::Consistent" },
				{ "Consistent.ToolTip", "@brief Slower but more accurate." },
				{ "Fast.Comment", "/**\n      * @brief Faster but with less precise calculations.\n      */" },
				{ "Fast.Name", "EReductionHeuristics::Fast" },
				{ "Fast.ToolTip", "@brief Faster but with less precise calculations." },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief The flag that decides how precise the reducer will be during the mesh reduction. Fast -> Reducer will be faster, but onscreensize and trianglecount will not match perfectly.  Consistent -> Reducer will be slower, but onscreensize and trianglecount will consistently give matching results." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EReductionHeuristics",
				"EReductionHeuristics",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EReductionTargetStopCondition_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("EReductionTargetStopCondition"));
		}
		return Singleton;
	}
	template<> SIMPLYGONUOBJECTS_API UEnum* StaticEnum<EReductionTargetStopCondition>()
	{
		return EReductionTargetStopCondition_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EReductionTargetStopCondition(EReductionTargetStopCondition_StaticEnum, TEXT("/Script/SimplygonUObjects"), TEXT("EReductionTargetStopCondition"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition_Hash() { return 179091573U; }
	UEnum* Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EReductionTargetStopCondition"), 0, Get_Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EReductionTargetStopCondition::Any", (int64)EReductionTargetStopCondition::Any },
				{ "EReductionTargetStopCondition::All", (int64)EReductionTargetStopCondition::All },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "All.Comment", "/**\n      * @brief Simplygon will continue processing until all of the reduction targets have been fulfilled.\n      */" },
				{ "All.Name", "EReductionTargetStopCondition::All" },
				{ "All.ToolTip", "@brief Simplygon will continue processing until all of the reduction targets have been fulfilled." },
				{ "Any.Comment", "/**\n      * @brief Simplygon will stop as soon as one of the reduction targets has been fulfilled.\n      */" },
				{ "Any.Name", "EReductionTargetStopCondition::Any" },
				{ "Any.ToolTip", "@brief Simplygon will stop as soon as one of the reduction targets has been fulfilled." },
				{ "BlueprintType", "true" },
				{ "Comment", "/**\n * @brief The stop condition for the reducer.  Any -> the reducer will stop when any single one of the set reduction targets have been reached.  All -> the reducer will stop when all enabled reduction targets have been set.\n */" },
				{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
				{ "ToolTip", "@brief The stop condition for the reducer.  Any -> the reducer will stop when any single one of the set reduction targets have been reached.  All -> the reducer will stop when all enabled reduction targets have been set." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonUObjects,
				nullptr,
				"EReductionTargetStopCondition",
				"EReductionTargetStopCondition",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}

static_assert(std::is_polymorphic<FImpostorFromSingleViewPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FImpostorFromSingleViewPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FImpostorFromSingleViewPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ImpostorFromSingleViewPipelineSettings"), sizeof(FImpostorFromSingleViewPipelineSettings), Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FImpostorFromSingleViewPipelineSettings>()
{
	return FImpostorFromSingleViewPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FImpostorFromSingleViewPipelineSettings(FImpostorFromSingleViewPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ImpostorFromSingleViewPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FImpostorFromSingleViewPipelineSettings>(FName(TEXT("ImpostorFromSingleViewPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewPipelineSettings;
	struct Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ImpostorFromSingleViewSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ImpostorFromSingleViewSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FImpostorFromSingleViewPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_ImpostorFromSingleViewSettings_MetaData[] = {
		{ "Category", "Impostor From Single View Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_ImpostorFromSingleViewSettings = { "ImpostorFromSingleViewSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewPipelineSettings, ImpostorFromSingleViewSettings), Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_ImpostorFromSingleViewSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_ImpostorFromSingleViewSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_ImpostorFromSingleViewSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"ImpostorFromSingleViewPipelineSettings",
		sizeof(FImpostorFromSingleViewPipelineSettings),
		alignof(FImpostorFromSingleViewPipelineSettings),
		Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ImpostorFromSingleViewPipelineSettings"), sizeof(FImpostorFromSingleViewPipelineSettings), Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewPipelineSettings_Hash() { return 3913734004U; }

static_assert(std::is_polymorphic<FFlipbookPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FFlipbookPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FFlipbookPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FFlipbookPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("FlipbookPipelineSettings"), sizeof(FFlipbookPipelineSettings), Get_Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FFlipbookPipelineSettings>()
{
	return FFlipbookPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FFlipbookPipelineSettings(FFlipbookPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("FlipbookPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FFlipbookPipelineSettings>(FName(TEXT("FlipbookPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookPipelineSettings;
	struct Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FlipbookSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_FlipbookSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FFlipbookPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_FlipbookSettings_MetaData[] = {
		{ "Category", "Flipbook Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_FlipbookSettings = { "FlipbookSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookPipelineSettings, FlipbookSettings), Z_Construct_UScriptStruct_FFlipbookSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_FlipbookSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_FlipbookSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_FlipbookSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"FlipbookPipelineSettings",
		sizeof(FFlipbookPipelineSettings),
		alignof(FFlipbookPipelineSettings),
		Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FFlipbookPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("FlipbookPipelineSettings"), sizeof(FFlipbookPipelineSettings), Get_Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FFlipbookPipelineSettings_Hash() { return 2339903695U; }

static_assert(std::is_polymorphic<FBillboardCloudVegetationPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FBillboardCloudVegetationPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FBillboardCloudVegetationPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("BillboardCloudVegetationPipelineSettings"), sizeof(FBillboardCloudVegetationPipelineSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FBillboardCloudVegetationPipelineSettings>()
{
	return FBillboardCloudVegetationPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FBillboardCloudVegetationPipelineSettings(FBillboardCloudVegetationPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("BillboardCloudVegetationPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudVegetationPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudVegetationPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FBillboardCloudVegetationPipelineSettings>(FName(TEXT("BillboardCloudVegetationPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudVegetationPipelineSettings;
	struct Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BillboardCloudSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_BillboardCloudSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FBillboardCloudVegetationPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData[] = {
		{ "Category", "Billboard Cloud Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_BillboardCloudSettings = { "BillboardCloudSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudVegetationPipelineSettings, BillboardCloudSettings), Z_Construct_UScriptStruct_FBillboardCloudSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudVegetationPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudVegetationPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_BillboardCloudSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"BillboardCloudVegetationPipelineSettings",
		sizeof(FBillboardCloudVegetationPipelineSettings),
		alignof(FBillboardCloudVegetationPipelineSettings),
		Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("BillboardCloudVegetationPipelineSettings"), sizeof(FBillboardCloudVegetationPipelineSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudVegetationPipelineSettings_Hash() { return 2278029149U; }

static_assert(std::is_polymorphic<FBillboardCloudPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FBillboardCloudPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FBillboardCloudPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("BillboardCloudPipelineSettings"), sizeof(FBillboardCloudPipelineSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FBillboardCloudPipelineSettings>()
{
	return FBillboardCloudPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FBillboardCloudPipelineSettings(FBillboardCloudPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("BillboardCloudPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FBillboardCloudPipelineSettings>(FName(TEXT("BillboardCloudPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudPipelineSettings;
	struct Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BillboardCloudSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_BillboardCloudSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FBillboardCloudPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData[] = {
		{ "Category", "Billboard Cloud Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_BillboardCloudSettings = { "BillboardCloudSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudPipelineSettings, BillboardCloudSettings), Z_Construct_UScriptStruct_FBillboardCloudSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_BillboardCloudSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_BillboardCloudSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"BillboardCloudPipelineSettings",
		sizeof(FBillboardCloudPipelineSettings),
		alignof(FBillboardCloudPipelineSettings),
		Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("BillboardCloudPipelineSettings"), sizeof(FBillboardCloudPipelineSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudPipelineSettings_Hash() { return 2316456363U; }

static_assert(std::is_polymorphic<FAggregationPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FAggregationPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FAggregationPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FAggregationPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FAggregationPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("AggregationPipelineSettings"), sizeof(FAggregationPipelineSettings), Get_Z_Construct_UScriptStruct_FAggregationPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FAggregationPipelineSettings>()
{
	return FAggregationPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FAggregationPipelineSettings(FAggregationPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("AggregationPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FAggregationPipelineSettings>(FName(TEXT("AggregationPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationPipelineSettings;
	struct Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_AggregationSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_AggregationSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VisibilitySettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VisibilitySettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryCullingSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_GeometryCullingSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VertexWeightSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VertexWeightSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateLightmapTexCoordSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_GenerateLightmapTexCoordSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FAggregationPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_AggregationSettings_MetaData[] = {
		{ "Category", "Aggregation Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_AggregationSettings = { "AggregationSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, AggregationSettings), Z_Construct_UScriptStruct_FAggregationSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_AggregationSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_AggregationSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData[] = {
		{ "Category", "Visibility Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VisibilitySettings = { "VisibilitySettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, VisibilitySettings), Z_Construct_UScriptStruct_FVisibilitySettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData[] = {
		{ "Category", "Geometry Culling Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GeometryCullingSettings = { "GeometryCullingSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, GeometryCullingSettings), Z_Construct_UScriptStruct_FGeometryCullingSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData[] = {
		{ "Category", "Vertex Weight Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VertexWeightSettings = { "VertexWeightSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, VertexWeightSettings), Z_Construct_UScriptStruct_FVertexWeightSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GenerateLightmapTexCoordSettings_MetaData[] = {
		{ "Category", "Generate Lightmap Tex Coord Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GenerateLightmapTexCoordSettings = { "GenerateLightmapTexCoordSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, GenerateLightmapTexCoordSettings), Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GenerateLightmapTexCoordSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GenerateLightmapTexCoordSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_AggregationSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VisibilitySettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GeometryCullingSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_VertexWeightSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_GenerateLightmapTexCoordSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"AggregationPipelineSettings",
		sizeof(FAggregationPipelineSettings),
		alignof(FAggregationPipelineSettings),
		Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FAggregationPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FAggregationPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("AggregationPipelineSettings"), sizeof(FAggregationPipelineSettings), Get_Z_Construct_UScriptStruct_FAggregationPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FAggregationPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FAggregationPipelineSettings_Hash() { return 538907526U; }

static_assert(std::is_polymorphic<FRemeshingPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FRemeshingPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FRemeshingPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FRemeshingPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("RemeshingPipelineSettings"), sizeof(FRemeshingPipelineSettings), Get_Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FRemeshingPipelineSettings>()
{
	return FRemeshingPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FRemeshingPipelineSettings(FRemeshingPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("RemeshingPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FRemeshingPipelineSettings>(FName(TEXT("RemeshingPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingPipelineSettings;
	struct Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemeshingSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_RemeshingSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_BoneSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryCullingSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_GeometryCullingSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VisibilitySettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VisibilitySettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRemeshingPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_RemeshingSettings_MetaData[] = {
		{ "Category", "Remeshing Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_RemeshingSettings = { "RemeshingSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, RemeshingSettings), Z_Construct_UScriptStruct_FRemeshingSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_RemeshingSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_RemeshingSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_BoneSettings_MetaData[] = {
		{ "Category", "Bone Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_BoneSettings = { "BoneSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, BoneSettings), Z_Construct_UScriptStruct_FBoneSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_BoneSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_BoneSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData[] = {
		{ "Category", "Geometry Culling Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_GeometryCullingSettings = { "GeometryCullingSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, GeometryCullingSettings), Z_Construct_UScriptStruct_FGeometryCullingSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_GeometryCullingSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData[] = {
		{ "Category", "Visibility Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_VisibilitySettings = { "VisibilitySettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, VisibilitySettings), Z_Construct_UScriptStruct_FVisibilitySettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_RemeshingSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_BoneSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_GeometryCullingSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_VisibilitySettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"RemeshingPipelineSettings",
		sizeof(FRemeshingPipelineSettings),
		alignof(FRemeshingPipelineSettings),
		Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FRemeshingPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("RemeshingPipelineSettings"), sizeof(FRemeshingPipelineSettings), Get_Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FRemeshingPipelineSettings_Hash() { return 1310766033U; }

static_assert(std::is_polymorphic<FReductionPipelineSettings>() == std::is_polymorphic<FSimplygonPipelineSettings>(), "USTRUCT FReductionPipelineSettings cannot be polymorphic unless super FSimplygonPipelineSettings is polymorphic");

class UScriptStruct* FReductionPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FReductionPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FReductionPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ReductionPipelineSettings"), sizeof(FReductionPipelineSettings), Get_Z_Construct_UScriptStruct_FReductionPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FReductionPipelineSettings>()
{
	return FReductionPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FReductionPipelineSettings(FReductionPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ReductionPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FReductionPipelineSettings>(FName(TEXT("ReductionPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionPipelineSettings;
	struct Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ReductionSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RepairSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_RepairSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NormalCalculationSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_NormalCalculationSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VisibilitySettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VisibilitySettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_BoneSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VertexWeightSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VertexWeightSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingImageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingImageSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_Inner_MetaData[];
#endif
		static const UE4CodeGen_Private::FObjectPropertyParams NewProp_MaterialPropertyCasters_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialPropertyCasters_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_MaterialPropertyCasters;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FReductionPipelineSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_ReductionSettings_MetaData[] = {
		{ "Category", "Reduction Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_ReductionSettings = { "ReductionSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, ReductionSettings), Z_Construct_UScriptStruct_FReductionSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_ReductionSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_ReductionSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_RepairSettings_MetaData[] = {
		{ "Category", "Repair Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_RepairSettings = { "RepairSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, RepairSettings), Z_Construct_UScriptStruct_FRepairSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_RepairSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_RepairSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_NormalCalculationSettings_MetaData[] = {
		{ "Category", "Normal Calculation Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_NormalCalculationSettings = { "NormalCalculationSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, NormalCalculationSettings), Z_Construct_UScriptStruct_FNormalCalculationSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_NormalCalculationSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_NormalCalculationSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData[] = {
		{ "Category", "Visibility Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VisibilitySettings = { "VisibilitySettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, VisibilitySettings), Z_Construct_UScriptStruct_FVisibilitySettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VisibilitySettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_BoneSettings_MetaData[] = {
		{ "Category", "Bone Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_BoneSettings = { "BoneSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, BoneSettings), Z_Construct_UScriptStruct_FBoneSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_BoneSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_BoneSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData[] = {
		{ "Category", "Vertex Weight Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VertexWeightSettings = { "VertexWeightSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, VertexWeightSettings), Z_Construct_UScriptStruct_FVertexWeightSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VertexWeightSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData[] = {
		{ "Category", "Mapping Image Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MappingImageSettings = { "MappingImageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, MappingImageSettings), Z_Construct_UScriptStruct_FMappingImageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MappingImageSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_USimplygonMaterialCaster_NoRegister, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData[] = {
		{ "Category", "Material Baking" },
		{ "EditInline", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters = { "MaterialPropertyCasters", nullptr, (EPropertyFlags)0x0010008000000009, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionPipelineSettings, MaterialPropertyCasters), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_ReductionSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_RepairSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_NormalCalculationSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VisibilitySettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_BoneSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_VertexWeightSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MappingImageSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::NewProp_MaterialPropertyCasters,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		Z_Construct_UScriptStruct_FSimplygonPipelineSettings,
		&NewStructOps,
		"ReductionPipelineSettings",
		sizeof(FReductionPipelineSettings),
		alignof(FReductionPipelineSettings),
		Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000205),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FReductionPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FReductionPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ReductionPipelineSettings"), sizeof(FReductionPipelineSettings), Get_Z_Construct_UScriptStruct_FReductionPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FReductionPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FReductionPipelineSettings_Hash() { return 1768995482U; }
class UScriptStruct* FVertexColorCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FVertexColorCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVertexColorCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("VertexColorCasterSettings"), sizeof(FVertexColorCasterSettings), Get_Z_Construct_UScriptStruct_FVertexColorCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FVertexColorCasterSettings>()
{
	return FVertexColorCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVertexColorCasterSettings(FVertexColorCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("VertexColorCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexColorCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexColorCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FVertexColorCasterSettings>(FName(TEXT("VertexColorCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexColorCasterSettings;
	struct Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputColorLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_OutputColorLevel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputColorName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OutputColorName;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ColorSpaceEdgeThreshold_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ColorSpaceEdgeThreshold;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVertexColorCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FVertexColorCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVertexColorCasterSettings), &Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorLevel_MetaData[] = {
		{ "Comment", "/** The OutputColorLevel index. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The OutputColorLevel index." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorLevel = { "OutputColorLevel", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OutputColorLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorLevel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_Dilation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorName_MetaData[] = {
		{ "Comment", "/** The OutputColorName string . */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The OutputColorName string ." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorName = { "OutputColorName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OutputColorName), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorName_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_ColorSpaceEdgeThreshold_MetaData[] = {
		{ "Category", "VertexColorCasterSettings" },
		{ "Comment", "/** The color space edge threshold, which will define how many hard color borders there will be. Corners more similar than the threshold will be merged. This works similarly to HardEdgeAngle for normals; lower values leads more hard borders between neighboring corner colors, and higher values will give you more shared, smoother, colors. This also impacts data usage when using packed geometry since (more unique colors) == (more vertices). The distance is measured in RGBA space. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The color space edge threshold, which will define how many hard color borders there will be. Corners more similar than the threshold will be merged. This works similarly to HardEdgeAngle for normals; lower values leads more hard borders between neighboring corner colors, and higher values will give you more shared, smoother, colors. This also impacts data usage when using packed geometry since (more unique colors) == (more vertices). The distance is measured in RGBA space." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_ColorSpaceEdgeThreshold = { "ColorSpaceEdgeThreshold", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexColorCasterSettings, ColorSpaceEdgeThreshold), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_ColorSpaceEdgeThreshold_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_ColorSpaceEdgeThreshold_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputColorName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::NewProp_ColorSpaceEdgeThreshold,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"VertexColorCasterSettings",
		sizeof(FVertexColorCasterSettings),
		alignof(FVertexColorCasterSettings),
		Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVertexColorCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVertexColorCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VertexColorCasterSettings"), sizeof(FVertexColorCasterSettings), Get_Z_Construct_UScriptStruct_FVertexColorCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVertexColorCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVertexColorCasterSettings_Hash() { return 3186088700U; }
class UScriptStruct* FGeometryDataCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FGeometryDataCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("GeometryDataCasterSettings"), sizeof(FGeometryDataCasterSettings), Get_Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FGeometryDataCasterSettings>()
{
	return FGeometryDataCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FGeometryDataCasterSettings(FGeometryDataCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("GeometryDataCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryDataCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryDataCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FGeometryDataCasterSettings>(FName(TEXT("GeometryDataCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryDataCasterSettings;
	struct Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_GeometryDataFieldType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryDataFieldType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_GeometryDataFieldType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryDataFieldIndex_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_GeometryDataFieldIndex;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingInfR_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingInfR;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingSupR_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingSupR;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingInfG_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingInfG;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingSupG_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingSupG;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingInfB_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingInfB;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingSupB_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingSupB;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingInfA_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingInfA;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingSupA_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MappingSupA;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingInf_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingInf;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MappingSup_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_MappingSup;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FGeometryDataCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FGeometryDataCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FGeometryDataCasterSettings), &Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The GeometryDataFieldType setting, which specifies what field type to cast in the GeometryDataCaster. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The GeometryDataFieldType setting, which specifies what field type to cast in the GeometryDataCaster." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType = { "GeometryDataFieldType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, GeometryDataFieldType), Z_Construct_UEnum_SimplygonUObjects_EGeometryDataFieldType, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_Dilation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldIndex_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The GeometryDataFieldIndex setting, which specifies what field index to cast in the GeometryDataCaster, for fields where it is applicable (TexCoords, Tangents, Bitangents and Colors). The setting is ignored for other field types. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The GeometryDataFieldIndex setting, which specifies what field index to cast in the GeometryDataCaster, for fields where it is applicable (TexCoords, Tangents, Bitangents and Colors). The setting is ignored for other field types." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldIndex = { "GeometryDataFieldIndex", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, GeometryDataFieldIndex), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldIndex_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldIndex_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfR_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfR = { "MappingInfR", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingInfR), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfR_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfR_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupR_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupR = { "MappingSupR", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingSupR), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupR_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupR_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfG_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfG = { "MappingInfG", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingInfG), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfG_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfG_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupG_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupG = { "MappingSupG", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingSupG), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupG_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupG_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfB_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfB = { "MappingInfB", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingInfB), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfB_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfB_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupB_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupB = { "MappingSupB", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingSupB), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupB_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupB_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfA_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** Property the inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Property the inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfA = { "MappingInfA", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingInfA), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfA_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfA_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupA_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** Property the Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Property the Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupA = { "MappingSupA", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingSupA), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupA_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupA_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInf_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The inferior/minimum value of field values to map onto the image data range (0->1). The minimum value will be represented by 0 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInf = { "MappingInf", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingInf), Z_Construct_UScriptStruct_FVector4, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInf_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInf_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSup_MetaData[] = {
		{ "Category", "GeometryDataCasterSettings" },
		{ "Comment", "/** The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Superior/maximum value of field values to map onto the image data range (0->1). The maximum value will be represented by 1 in the image. Note that the mapping is only used for real value fields, not id-based fields, which cannot be scaled accurately." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSup = { "MappingSup", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryDataCasterSettings, MappingSup), Z_Construct_UScriptStruct_FVector4, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSup_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSup_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_GeometryDataFieldIndex,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfR,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupR,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfG,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupG,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfB,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupB,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInfA,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSupA,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingInf,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::NewProp_MappingSup,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"GeometryDataCasterSettings",
		sizeof(FGeometryDataCasterSettings),
		alignof(FGeometryDataCasterSettings),
		Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FGeometryDataCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("GeometryDataCasterSettings"), sizeof(FGeometryDataCasterSettings), Get_Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FGeometryDataCasterSettings_Hash() { return 2412900470U; }
class UScriptStruct* FAmbientOcclusionCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("AmbientOcclusionCasterSettings"), sizeof(FAmbientOcclusionCasterSettings), Get_Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FAmbientOcclusionCasterSettings>()
{
	return FAmbientOcclusionCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FAmbientOcclusionCasterSettings(FAmbientOcclusionCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("AmbientOcclusionCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAmbientOcclusionCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAmbientOcclusionCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FAmbientOcclusionCasterSettings>(FName(TEXT("AmbientOcclusionCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFAmbientOcclusionCasterSettings;
	struct Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RaysPerPixel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_RaysPerPixel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OcclusionFalloff_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_OcclusionFalloff;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OcclusionMultiplier_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_OcclusionMultiplier;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseSimpleOcclusionMode_MetaData[];
#endif
		static void NewProp_UseSimpleOcclusionMode_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseSimpleOcclusionMode;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FAmbientOcclusionCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FAmbientOcclusionCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAmbientOcclusionCasterSettings), &Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_RaysPerPixel_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** This determines how many rays are traced per pixel (or subpixel) to evaluate the occlusion. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This determines how many rays are traced per pixel (or subpixel) to evaluate the occlusion." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_RaysPerPixel = { "RaysPerPixel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, RaysPerPixel), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_RaysPerPixel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_RaysPerPixel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_Dilation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionFalloff_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** How far away a surface has to be from another surface to generate no occlusion. Only applicable if SimpleOcclusionMode is off. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "How far away a surface has to be from another surface to generate no occlusion. Only applicable if SimpleOcclusionMode is off." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionFalloff = { "OcclusionFalloff", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OcclusionFalloff), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionFalloff_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionFalloff_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionMultiplier_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** This is just a basic intensity scaler. Higher is 'darker'. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This is just a basic intensity scaler. Higher is 'darker'." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionMultiplier = { "OcclusionMultiplier", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAmbientOcclusionCasterSettings, OcclusionMultiplier), METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionMultiplier_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionMultiplier_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode_MetaData[] = {
		{ "Category", "AmbientOcclusionCasterSettings" },
		{ "Comment", "/** If set, occlusion will not scale with distance, each ray will only be either fully occluded or not at all. Speeds up processing time. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, occlusion will not scale with distance, each ray will only be either fully occluded or not at all. Speeds up processing time." },
	};
#endif
	void Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode_SetBit(void* Obj)
	{
		((FAmbientOcclusionCasterSettings*)Obj)->UseSimpleOcclusionMode = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode = { "UseSimpleOcclusionMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAmbientOcclusionCasterSettings), &Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_RaysPerPixel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionFalloff,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_OcclusionMultiplier,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::NewProp_UseSimpleOcclusionMode,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"AmbientOcclusionCasterSettings",
		sizeof(FAmbientOcclusionCasterSettings),
		alignof(FAmbientOcclusionCasterSettings),
		Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("AmbientOcclusionCasterSettings"), sizeof(FAmbientOcclusionCasterSettings), Get_Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings_Hash() { return 319814904U; }
class UScriptStruct* FDisplacementCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FDisplacementCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FDisplacementCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("DisplacementCasterSettings"), sizeof(FDisplacementCasterSettings), Get_Z_Construct_UScriptStruct_FDisplacementCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FDisplacementCasterSettings>()
{
	return FDisplacementCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FDisplacementCasterSettings(FDisplacementCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("DisplacementCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFDisplacementCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFDisplacementCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FDisplacementCasterSettings>(FName(TEXT("DisplacementCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFDisplacementCasterSettings;
	struct Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DistanceScaling_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_DistanceScaling;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateScalarDisplacement_MetaData[];
#endif
		static void NewProp_GenerateScalarDisplacement_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateScalarDisplacement;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateTangentSpaceDisplacement_MetaData[];
#endif
		static void NewProp_GenerateTangentSpaceDisplacement_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateTangentSpaceDisplacement;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NormalMapTexCoordLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_NormalMapTexCoordLevel;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FDisplacementCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FDisplacementCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FDisplacementCasterSettings), &Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DistanceScaling_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** All the delta values are divided by this value before storing them into an image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "All the delta values are divided by this value before storing them into an image." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DistanceScaling = { "DistanceScaling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, DistanceScaling), METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DistanceScaling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DistanceScaling_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_Dilation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** If set to true, the size of the displacement vector components in the direction of the interpolated normal are stored in the displacement map, instead of the displacement vectors. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set to true, the size of the displacement vector components in the direction of the interpolated normal are stored in the displacement map, instead of the displacement vectors." },
	};
#endif
	void Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement_SetBit(void* Obj)
	{
		((FDisplacementCasterSettings*)Obj)->GenerateScalarDisplacement = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement = { "GenerateScalarDisplacement", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FDisplacementCasterSettings), &Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** If set, the displacement vectors are transformed into the destination object tangent space. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the displacement vectors are transformed into the destination object tangent space." },
	};
#endif
	void Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement_SetBit(void* Obj)
	{
		((FDisplacementCasterSettings*)Obj)->GenerateTangentSpaceDisplacement = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement = { "GenerateTangentSpaceDisplacement", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FDisplacementCasterSettings), &Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_NormalMapTexCoordLevel_MetaData[] = {
		{ "Category", "DisplacementCasterSettings" },
		{ "Comment", "/** The texture coordinate level to use for the tangent space displacement vectors. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The texture coordinate level to use for the tangent space displacement vectors." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_NormalMapTexCoordLevel = { "NormalMapTexCoordLevel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FDisplacementCasterSettings, NormalMapTexCoordLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_NormalMapTexCoordLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_NormalMapTexCoordLevel_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_DistanceScaling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateScalarDisplacement,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_GenerateTangentSpaceDisplacement,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::NewProp_NormalMapTexCoordLevel,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"DisplacementCasterSettings",
		sizeof(FDisplacementCasterSettings),
		alignof(FDisplacementCasterSettings),
		Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FDisplacementCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FDisplacementCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("DisplacementCasterSettings"), sizeof(FDisplacementCasterSettings), Get_Z_Construct_UScriptStruct_FDisplacementCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FDisplacementCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FDisplacementCasterSettings_Hash() { return 503920003U; }
class UScriptStruct* FNormalCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FNormalCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FNormalCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("NormalCasterSettings"), sizeof(FNormalCasterSettings), Get_Z_Construct_UScriptStruct_FNormalCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FNormalCasterSettings>()
{
	return FNormalCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FNormalCasterSettings(FNormalCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("NormalCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FNormalCasterSettings>(FName(TEXT("NormalCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCasterSettings;
	struct Z_Construct_UScriptStruct_FNormalCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FlipBackfacingNormals_MetaData[];
#endif
		static void NewProp_FlipBackfacingNormals_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_FlipBackfacingNormals;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateTangentSpaceNormals_MetaData[];
#endif
		static void NewProp_GenerateTangentSpaceNormals_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateTangentSpaceNormals;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FlipGreen_MetaData[];
#endif
		static void NewProp_FlipGreen_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_FlipGreen;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CalculateBitangentPerFragment_MetaData[];
#endif
		static void NewProp_CalculateBitangentPerFragment_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_CalculateBitangentPerFragment;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NormalizeInterpolatedTangentSpace_MetaData[];
#endif
		static void NewProp_NormalizeInterpolatedTangentSpace_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_NormalizeInterpolatedTangentSpace;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FNormalCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** If set, then normals will be flipped if they are back facing, i.e. pointing into the surface. This may introduce artifacts on geometries that have correctly facing normals, so only use for geometries with known back-facing normals. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, then normals will be flipped if they are back facing, i.e. pointing into the surface. This may introduce artifacts on geometries that have correctly facing normals, so only use for geometries with known back-facing normals." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->FlipBackfacingNormals = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals = { "FlipBackfacingNormals", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_Dilation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** If set, then the generated normal map will be in tangent space. Please note that the geometry casted to must contain tangent space fields. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, then the generated normal map will be in tangent space. Please note that the geometry casted to must contain tangent space fields." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->GenerateTangentSpaceNormals = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals = { "GenerateTangentSpaceNormals", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** If set, the green channel is assumed to point along the negative bitangent instead of the positive. This is roughly equivalent to switching between left- and righthanded, but some rounding may differ. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the green channel is assumed to point along the negative bitangent instead of the positive. This is roughly equivalent to switching between left- and righthanded, but some rounding may differ." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->FlipGreen = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen = { "FlipGreen", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** If set, the normal caster calculates the bitangent used for encoding per-fragment using the normal, tangent and bitangent sign instead of interpolating the actual bitangent vertex data. This needs to match the behavior of the renderer to not produce rendering artifacts. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the normal caster calculates the bitangent used for encoding per-fragment using the normal, tangent and bitangent sign instead of interpolating the actual bitangent vertex data. This needs to match the behavior of the renderer to not produce rendering artifacts." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->CalculateBitangentPerFragment = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment = { "CalculateBitangentPerFragment", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace_MetaData[] = {
		{ "Category", "NormalCasterSettings" },
		{ "Comment", "/** If set, the normal caster normalizes the normal and tangent data used for encoding after interpolation. This needs to match the behavior of the renderer to not produce rendering artifacts. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the normal caster normalizes the normal and tangent data used for encoding after interpolation. This needs to match the behavior of the renderer to not produce rendering artifacts." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace_SetBit(void* Obj)
	{
		((FNormalCasterSettings*)Obj)->NormalizeInterpolatedTangentSpace = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace = { "NormalizeInterpolatedTangentSpace", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCasterSettings), &Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipBackfacingNormals,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_GenerateTangentSpaceNormals,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_FlipGreen,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_CalculateBitangentPerFragment,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::NewProp_NormalizeInterpolatedTangentSpace,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"NormalCasterSettings",
		sizeof(FNormalCasterSettings),
		alignof(FNormalCasterSettings),
		Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FNormalCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FNormalCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("NormalCasterSettings"), sizeof(FNormalCasterSettings), Get_Z_Construct_UScriptStruct_FNormalCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FNormalCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FNormalCasterSettings_Hash() { return 31466129U; }
class UScriptStruct* FOpacityCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FOpacityCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FOpacityCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("OpacityCasterSettings"), sizeof(FOpacityCasterSettings), Get_Z_Construct_UScriptStruct_FOpacityCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FOpacityCasterSettings>()
{
	return FOpacityCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FOpacityCasterSettings(FOpacityCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("OpacityCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFOpacityCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFOpacityCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FOpacityCasterSettings>(FName(TEXT("OpacityCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFOpacityCasterSettings;
	struct Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputSRGB_MetaData[];
#endif
		static void NewProp_OutputSRGB_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_OutputSRGB;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputOpacityType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputOpacityType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputOpacityType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FOpacityCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FOpacityCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FOpacityCasterSettings), &Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** If set, output textures are exported in sRGB format. Input texture format is determined by the flag in the corresponding texture node in the material definition. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, output textures are exported in sRGB format. Input texture format is determined by the flag in the corresponding texture node in the material definition." },
	};
#endif
	void Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB_SetBit(void* Obj)
	{
		((FOpacityCasterSettings*)Obj)->OutputSRGB = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB = { "OutputSRGB", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FOpacityCasterSettings), &Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_Dilation_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency' */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency'" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType = { "OutputOpacityType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OutputOpacityType), Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "OpacityCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOpacityCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputSRGB,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputOpacityType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::NewProp_OutputPixelFormat,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"OpacityCasterSettings",
		sizeof(FOpacityCasterSettings),
		alignof(FOpacityCasterSettings),
		Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FOpacityCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FOpacityCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("OpacityCasterSettings"), sizeof(FOpacityCasterSettings), Get_Z_Construct_UScriptStruct_FOpacityCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FOpacityCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FOpacityCasterSettings_Hash() { return 2598212233U; }
class UScriptStruct* FColorCasterSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FColorCasterSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FColorCasterSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ColorCasterSettings"), sizeof(FColorCasterSettings), Get_Z_Construct_UScriptStruct_FColorCasterSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FColorCasterSettings>()
{
	return FColorCasterSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FColorCasterSettings(FColorCasterSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ColorCasterSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFColorCasterSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFColorCasterSettings()
	{
		UScriptStruct::DeferCppStructOps<FColorCasterSettings>(FName(TEXT("ColorCasterSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFColorCasterSettings;
	struct Z_Construct_UScriptStruct_FColorCasterSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_MaterialChannel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OpacityChannelComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannelComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OpacityChannelComponent;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DitherType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DitherType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DitherType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_FillMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FillMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OpacityChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseMultisampling_MetaData[];
#endif
		static void NewProp_UseMultisampling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseMultisampling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BakeOpacityInAlpha_MetaData[];
#endif
		static void NewProp_BakeOpacityInAlpha_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BakeOpacityInAlpha;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputImageFileFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputImageFileFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputImageFileFormat;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputDDSCompressionType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputDDSCompressionType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputDDSCompressionType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Dilation_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Dilation;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputOpacityType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputOpacityType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputOpacityType;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_OutputPixelFormat_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputPixelFormat_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_OutputPixelFormat;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SkipCastingIfNoInputChannel_MetaData[];
#endif
		static void NewProp_SkipCastingIfNoInputChannel_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_SkipCastingIfNoInputChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputSRGB_MetaData[];
#endif
		static void NewProp_OutputSRGB_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_OutputSRGB;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FColorCasterSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input material channel to cast. Existing user channels of any arbitrary name in the input materials can be cast." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_MaterialChannel = { "MaterialChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, MaterialChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_MaterialChannel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The component in the opacity channel to use as opacity value. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The component in the opacity channel to use as opacity value." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent = { "OpacityChannelComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OpacityChannelComponent), Z_Construct_UEnum_SimplygonUObjects_EOpacityChannelComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The type of dithering to use when creating the output object. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The type of dithering to use when creating the output object." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType = { "DitherType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, DitherType), Z_Construct_UEnum_SimplygonUObjects_EDitherType, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The fill mode determines what to do with the pixels that remain unfilled after both the casting and dilation has been performed. Options are:  None = Do not fill remaining pixels  Interpolate = linearly interpolate the closest samples  NearestNeighbor = use the closest available pixel value without interpolation." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode = { "FillMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, FillMode), Z_Construct_UEnum_SimplygonUObjects_EFillMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the input opacity channel to use for combining layers in most casters and casting opacity in the opacitycaster. User channels of any arbitrary name can be used. If the caster is run through a Pipeline object, the OpacityChannel set here will also be set as the output materials OpacityChannel property." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannel = { "OpacityChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OpacityChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** Enable or disable multisampling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable or disable multisampling." },
	};
#endif
	void Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling_SetBit(void* Obj)
	{
		((FColorCasterSettings*)Obj)->UseMultisampling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling = { "UseMultisampling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FColorCasterSettings), &Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** If set, the total opacity of the baked layers replaces the alpha value in the output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the total opacity of the baked layers replaces the alpha value in the output texture." },
	};
#endif
	void Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha_SetBit(void* Obj)
	{
		((FColorCasterSettings*)Obj)->BakeOpacityInAlpha = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha = { "BakeOpacityInAlpha", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FColorCasterSettings), &Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData[] = {
		{ "Comment", "/** File format for output texture. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "File format for output texture." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat = { "OutputImageFileFormat", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OutputImageFileFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputImageFileFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData[] = {
		{ "Comment", "/** DDS compression if output format is DDS. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "DDS compression if output format is DDS." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType = { "OutputDDSCompressionType", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OutputDDSCompressionType), Z_Construct_UEnum_SimplygonUObjects_EOutputDDSCompressionType, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_Dilation_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The Dilation value. Where applicable, such as colors and normals, the caster will fill empty pixels surrounding filled pixels with values mixed from the filled ones. This setting sets how many pixels to fill outside the original filled pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_Dilation = { "Dilation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, Dilation), METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_Dilation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_Dilation_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency' */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The opacity type determines how the opacity channel of this material should be saved. To make (0.0->1.0) map to (transparent-opaque), use 'Opacity'. To make (0.0->1.0) map to (opaque-transparent), use 'Transparency'" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType = { "OutputOpacityType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OutputOpacityType), Z_Construct_UEnum_SimplygonUObjects_EOutputOpacityType, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** The output pixel format */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The output pixel format" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat = { "OutputPixelFormat", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FColorCasterSettings, OutputPixelFormat), Z_Construct_UEnum_SimplygonUObjects_EOutputPixelFormat, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** If this flag is set, the caster will only run if there is at least one input material that has the main input channel which is to be cast. If the flag is not set, the caster will always produce an output, even if it is totally empty/unset. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If this flag is set, the caster will only run if there is at least one input material that has the main input channel which is to be cast. If the flag is not set, the caster will always produce an output, even if it is totally empty/unset." },
	};
#endif
	void Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel_SetBit(void* Obj)
	{
		((FColorCasterSettings*)Obj)->SkipCastingIfNoInputChannel = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel = { "SkipCastingIfNoInputChannel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FColorCasterSettings), &Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB_MetaData[] = {
		{ "Category", "ColorCasterSettings" },
		{ "Comment", "/** If set, output textures are exported in sRGB format. Input texture format is determined by the flag in the corresponding texture node in the material definition. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, output textures are exported in sRGB format. Input texture format is determined by the flag in the corresponding texture node in the material definition." },
	};
#endif
	void Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB_SetBit(void* Obj)
	{
		((FColorCasterSettings*)Obj)->OutputSRGB = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB = { "OutputSRGB", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FColorCasterSettings), &Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FColorCasterSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_MaterialChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannelComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_DitherType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_FillMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OpacityChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_UseMultisampling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_BakeOpacityInAlpha,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputImageFileFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputDDSCompressionType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_Dilation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputOpacityType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputPixelFormat,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_SkipCastingIfNoInputChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FColorCasterSettings_Statics::NewProp_OutputSRGB,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FColorCasterSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"ColorCasterSettings",
		sizeof(FColorCasterSettings),
		alignof(FColorCasterSettings),
		Z_Construct_UScriptStruct_FColorCasterSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FColorCasterSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FColorCasterSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FColorCasterSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ColorCasterSettings"), sizeof(FColorCasterSettings), Get_Z_Construct_UScriptStruct_FColorCasterSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FColorCasterSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FColorCasterSettings_Hash() { return 3152316047U; }
class UScriptStruct* FImpostorFromSingleViewSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ImpostorFromSingleViewSettings"), sizeof(FImpostorFromSingleViewSettings), Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FImpostorFromSingleViewSettings>()
{
	return FImpostorFromSingleViewSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FImpostorFromSingleViewSettings(FImpostorFromSingleViewSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ImpostorFromSingleViewSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewSettings()
	{
		UScriptStruct::DeferCppStructOps<FImpostorFromSingleViewSettings>(FName(TEXT("ImpostorFromSingleViewSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFImpostorFromSingleViewSettings;
	struct Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseTightFitting_MetaData[];
#endif
		static void NewProp_UseTightFitting_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseTightFitting;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TightFittingDepthOffset_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_TightFittingDepthOffset;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TwoSided_MetaData[];
#endif
		static void NewProp_TwoSided_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_TwoSided;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ViewDirection_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ViewDirection;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TexCoordPadding_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_TexCoordPadding;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FImpostorFromSingleViewSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting_MetaData[] = {
		{ "Category", "ImpostorFromSingleViewSettings" },
		{ "Comment", "/** If set, the impostor will exactly conform to the bounds of the geometry. If false, its dimensions will always be diameter*diameter. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the impostor will exactly conform to the bounds of the geometry. If false, its dimensions will always be diameter*diameter." },
	};
#endif
	void Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting_SetBit(void* Obj)
	{
		((FImpostorFromSingleViewSettings*)Obj)->UseTightFitting = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting = { "UseTightFitting", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FImpostorFromSingleViewSettings), &Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TightFittingDepthOffset_MetaData[] = {
		{ "Category", "ImpostorFromSingleViewSettings" },
		{ "Comment", "/** This determines where the impostor will end up in depth. 0 is 'center', 1 is 'front' and -1 is 'back'. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This determines where the impostor will end up in depth. 0 is 'center', 1 is 'front' and -1 is 'back'." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TightFittingDepthOffset = { "TightFittingDepthOffset", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewSettings, TightFittingDepthOffset), METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TightFittingDepthOffset_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TightFittingDepthOffset_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided_MetaData[] = {
		{ "Category", "ImpostorFromSingleViewSettings" },
		{ "Comment", "/** If set, the impostor will contain both front and back facing surfaces. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the impostor will contain both front and back facing surfaces." },
	};
#endif
	void Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided_SetBit(void* Obj)
	{
		((FImpostorFromSingleViewSettings*)Obj)->TwoSided = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided = { "TwoSided", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FImpostorFromSingleViewSettings), &Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_ViewDirection_MetaData[] = {
		{ "Category", "ImpostorFromSingleViewSettings" },
		{ "Comment", "/** This vector determines how the resulting impostor geometry will be oriented. The billboard will be perpendicular to this vector. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This vector determines how the resulting impostor geometry will be oriented. The billboard will be perpendicular to this vector." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_ViewDirection = { "ViewDirection", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewSettings, ViewDirection), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_ViewDirection_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_ViewDirection_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TexCoordPadding_MetaData[] = {
		{ "Category", "ImpostorFromSingleViewSettings" },
		{ "Comment", "/** Normally, the processor will generate an impostor with texcoords from 0.0 to 1.0, giving perfect UV coverage in the final texture. If your engine uses permanent tiling rendering mode, you may need to add a small padding to avoid sub-pixel wrapping artifact at the impostor edges, which this setting supplies. Ex: Setting this to 0.01 will generate texcoords in the range 0.01 to 0.99. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Normally, the processor will generate an impostor with texcoords from 0.0 to 1.0, giving perfect UV coverage in the final texture. If your engine uses permanent tiling rendering mode, you may need to add a small padding to avoid sub-pixel wrapping artifact at the impostor edges, which this setting supplies. Ex: Setting this to 0.01 will generate texcoords in the range 0.01 to 0.99." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TexCoordPadding = { "TexCoordPadding", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FImpostorFromSingleViewSettings, TexCoordPadding), METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TexCoordPadding_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TexCoordPadding_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_UseTightFitting,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TightFittingDepthOffset,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TwoSided,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_ViewDirection,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::NewProp_TexCoordPadding,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"ImpostorFromSingleViewSettings",
		sizeof(FImpostorFromSingleViewSettings),
		alignof(FImpostorFromSingleViewSettings),
		Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ImpostorFromSingleViewSettings"), sizeof(FImpostorFromSingleViewSettings), Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FImpostorFromSingleViewSettings_Hash() { return 1527367055U; }
class UScriptStruct* FFlipbookSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FFlipbookSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FFlipbookSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("FlipbookSettings"), sizeof(FFlipbookSettings), Get_Z_Construct_UScriptStruct_FFlipbookSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FFlipbookSettings>()
{
	return FFlipbookSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FFlipbookSettings(FFlipbookSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("FlipbookSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookSettings()
	{
		UScriptStruct::DeferCppStructOps<FFlipbookSettings>(FName(TEXT("FlipbookSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFFlipbookSettings;
	struct Z_Construct_UScriptStruct_FFlipbookSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NumberOfViews_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_NumberOfViews;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ViewDirection_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ViewDirection;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UpVector_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_UpVector;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FFlipbookSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_NumberOfViews_MetaData[] = {
		{ "Category", "FlipbookSettings" },
		{ "Comment", "/** Determines the number of views generated for the flip book impostor. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines the number of views generated for the flip book impostor." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_NumberOfViews = { "NumberOfViews", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookSettings, NumberOfViews), METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_NumberOfViews_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_NumberOfViews_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_ViewDirection_MetaData[] = {
		{ "Category", "FlipbookSettings" },
		{ "Comment", "/** This vector determines the direction of the first view. The rest of the views are uniformly distributed around the scene rotated around the up-vector. The resulting billboard will be oriented in the negative view direction. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This vector determines the direction of the first view. The rest of the views are uniformly distributed around the scene rotated around the up-vector. The resulting billboard will be oriented in the negative view direction." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_ViewDirection = { "ViewDirection", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookSettings, ViewDirection), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_ViewDirection_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_ViewDirection_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_UpVector_MetaData[] = {
		{ "Category", "FlipbookSettings" },
		{ "Comment", "/** The views are rotated around the up vector and the rendered images are oriented with the up vector. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The views are rotated around the up vector and the rendered images are oriented with the up vector." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_UpVector = { "UpVector", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFlipbookSettings, UpVector), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_UpVector_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_UpVector_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FFlipbookSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_NumberOfViews,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_ViewDirection,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFlipbookSettings_Statics::NewProp_UpVector,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FFlipbookSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"FlipbookSettings",
		sizeof(FFlipbookSettings),
		alignof(FFlipbookSettings),
		Z_Construct_UScriptStruct_FFlipbookSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFlipbookSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FFlipbookSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FFlipbookSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("FlipbookSettings"), sizeof(FFlipbookSettings), Get_Z_Construct_UScriptStruct_FFlipbookSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FFlipbookSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FFlipbookSettings_Hash() { return 3534045212U; }
class UScriptStruct* FBillboardCloudSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FBillboardCloudSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("BillboardCloudSettings"), sizeof(FBillboardCloudSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FBillboardCloudSettings>()
{
	return FBillboardCloudSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FBillboardCloudSettings(FBillboardCloudSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("BillboardCloudSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudSettings()
	{
		UScriptStruct::DeferCppStructOps<FBillboardCloudSettings>(FName(TEXT("BillboardCloudSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFBillboardCloudSettings;
	struct Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_BillboardMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BillboardMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_BillboardMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FavorVerticalPlanes_MetaData[];
#endif
		static void NewProp_FavorVerticalPlanes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_FavorVerticalPlanes;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TwoSided_MetaData[];
#endif
		static void NewProp_TwoSided_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_TwoSided;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseVisibilityWeights_MetaData[];
#endif
		static void NewProp_UseVisibilityWeights_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseVisibilityWeights;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BillboardDensity_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_BillboardDensity;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaxPlaneCount_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_MaxPlaneCount;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometricComplexity_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GeometricComplexity;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UpVector_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_UpVector;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FoliageSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_FoliageSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FBillboardCloudSettings>();
	}
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Specifies how the impostors should be mapped to the scene. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Specifies how the impostors should be mapped to the scene." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode = { "BillboardMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, BillboardMode), Z_Construct_UEnum_SimplygonUObjects_EBillboardMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Determines whether to prioritize generating vertical billboards which means they will be optimized to be viewed from the side. Otherwise, if the geometry in the input scene is mostly facing upwards/downwards then the generated billboards will also be facing upwards/downwards which makes them not well suited to being viewed from the side. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines whether to prioritize generating vertical billboards which means they will be optimized to be viewed from the side. Otherwise, if the geometry in the input scene is mostly facing upwards/downwards then the generated billboards will also be facing upwards/downwards which makes them not well suited to being viewed from the side." },
	};
#endif
	void Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes_SetBit(void* Obj)
	{
		((FBillboardCloudSettings*)Obj)->FavorVerticalPlanes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes = { "FavorVerticalPlanes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBillboardCloudSettings), &Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Only applicable if BillboardMode: Foliage. Determines if the scene is intended to be viewed from both sides without back face culling. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only applicable if BillboardMode: Foliage. Determines if the scene is intended to be viewed from both sides without back face culling." },
	};
#endif
	void Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided_SetBit(void* Obj)
	{
		((FBillboardCloudSettings*)Obj)->TwoSided = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided = { "TwoSided", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBillboardCloudSettings), &Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Determines whether to prioritize accurately mapping triangles with higher visibility to billboards. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines whether to prioritize accurately mapping triangles with higher visibility to billboards." },
	};
#endif
	void Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights_SetBit(void* Obj)
	{
		((FBillboardCloudSettings*)Obj)->UseVisibilityWeights = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights = { "UseVisibilityWeights", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBillboardCloudSettings), &Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardDensity_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Determines how many billboards to create. A large BillboardDensity means that more billboards will be created to represent spatially spread out triangles better. Having a low BillboardDensity means that fewer billboards will be created and the distances from original leaves to billboards will get larger. The range is 0->1. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines how many billboards to create. A large BillboardDensity means that more billboards will be created to represent spatially spread out triangles better. Having a low BillboardDensity means that fewer billboards will be created and the distances from original leaves to billboards will get larger. The range is 0->1." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardDensity = { "BillboardDensity", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, BillboardDensity), METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardDensity_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardDensity_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_MaxPlaneCount_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Determines the maximum billboard count. When this criteria is met, it is not guaranteed that all triangles in the scene have been accurately mapped to a billboard yet. Triangles that have not been mapped to a billboard within the BillboardMaxDeviation distance will be mapped to an existing billboard that best represents the triangle. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines the maximum billboard count. When this criteria is met, it is not guaranteed that all triangles in the scene have been accurately mapped to a billboard yet. Triangles that have not been mapped to a billboard within the BillboardMaxDeviation distance will be mapped to an existing billboard that best represents the triangle." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_MaxPlaneCount = { "MaxPlaneCount", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, MaxPlaneCount), METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_MaxPlaneCount_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_MaxPlaneCount_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_GeometricComplexity_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** Determines the geometric complexity of the billboards. The value range is 0->1, where a value of Zero means that the billboards will be simple and not follow the projection closely. And a value of One means that the geometric complexity will be increased and follow the projection closely. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines the geometric complexity of the billboards. The value range is 0->1, where a value of Zero means that the billboards will be simple and not follow the projection closely. And a value of One means that the geometric complexity will be increased and follow the projection closely." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_GeometricComplexity = { "GeometricComplexity", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, GeometricComplexity), METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_GeometricComplexity_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_GeometricComplexity_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UpVector_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "Comment", "/** The UpVector used in the Billboard Cloud Processor. Set this if the input scene has an up vector other than Y+. If FavorVerticalPlanes is enabled, the UpVector determines verticality. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The UpVector used in the Billboard Cloud Processor. Set this if the input scene has an up vector other than Y+. If FavorVerticalPlanes is enabled, the UpVector determines verticality." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UpVector = { "UpVector", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, UpVector), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UpVector_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UpVector_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FoliageSettings_MetaData[] = {
		{ "Category", "BillboardCloudSettings" },
		{ "EditCondition", "BillboardMode==EBillboardMode::Foliage" },
		{ "EditConditionHides", "" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FoliageSettings = { "FoliageSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBillboardCloudSettings, FoliageSettings), Z_Construct_UScriptStruct_FFoliageSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FoliageSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FoliageSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FavorVerticalPlanes,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_TwoSided,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UseVisibilityWeights,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_BillboardDensity,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_MaxPlaneCount,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_GeometricComplexity,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_UpVector,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::NewProp_FoliageSettings,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"BillboardCloudSettings",
		sizeof(FBillboardCloudSettings),
		alignof(FBillboardCloudSettings),
		Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FBillboardCloudSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("BillboardCloudSettings"), sizeof(FBillboardCloudSettings), Get_Z_Construct_UScriptStruct_FBillboardCloudSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FBillboardCloudSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FBillboardCloudSettings_Hash() { return 4099381033U; }
class UScriptStruct* FFoliageSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FFoliageSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FFoliageSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("FoliageSettings"), sizeof(FFoliageSettings), Get_Z_Construct_UScriptStruct_FFoliageSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FFoliageSettings>()
{
	return FFoliageSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FFoliageSettings(FFoliageSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("FoliageSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFoliageSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFFoliageSettings()
	{
		UScriptStruct::DeferCppStructOps<FFoliageSettings>(FName(TEXT("FoliageSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFFoliageSettings;
	struct Z_Construct_UScriptStruct_FFoliageSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateTrunkAndFoliage_MetaData[];
#endif
		static void NewProp_SeparateTrunkAndFoliage_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_SeparateTrunkAndFoliage;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateFoliageTriangleRatio_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SeparateFoliageTriangleRatio;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateFoliageTriangleThreshold_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_SeparateFoliageTriangleThreshold;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateFoliageAreaThreshold_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SeparateFoliageAreaThreshold;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateFoliageSizeThreshold_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SeparateFoliageSizeThreshold;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TrunkReductionRatio_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_TrunkReductionRatio;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FFoliageSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Determines whether to enable separation between foliage and trunk in a vegetation scene. Use the SeparateFoliage[...] settings to determine how parts are separated. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines whether to enable separation between foliage and trunk in a vegetation scene. Use the SeparateFoliage[...] settings to determine how parts are separated." },
	};
#endif
	void Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage_SetBit(void* Obj)
	{
		((FFoliageSettings*)Obj)->SeparateTrunkAndFoliage = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage = { "SeparateTrunkAndFoliage", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FFoliageSettings), &Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleRatio_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Is used to separate the trunk from the foliage in a vegetation scene by comparing each group of connected triangles in the scene with the scene's largest group. If a group's triangle count is below SeparateFoliageTriangleRatio * largestGrouptriangleCount it is treated as foliage and processed into billboards. The trunk is optimized using triangle reduction. The range is 0.0->1.0. 0.0 means nothing will be foliage, 1.0 means everything will be foliage. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Is used to separate the trunk from the foliage in a vegetation scene by comparing each group of connected triangles in the scene with the scene's largest group. If a group's triangle count is below SeparateFoliageTriangleRatio * largestGrouptriangleCount it is treated as foliage and processed into billboards. The trunk is optimized using triangle reduction. The range is 0.0->1.0. 0.0 means nothing will be foliage, 1.0 means everything will be foliage." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleRatio = { "SeparateFoliageTriangleRatio", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFoliageSettings, SeparateFoliageTriangleRatio), METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleRatio_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleRatio_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleThreshold_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the triangle count is below SeparateFoliageTriangleThreshold it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the maximum triangle count means everything will be foliage. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the triangle count is below SeparateFoliageTriangleThreshold it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the maximum triangle count means everything will be foliage." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleThreshold = { "SeparateFoliageTriangleThreshold", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFoliageSettings, SeparateFoliageTriangleThreshold), METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleThreshold_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleThreshold_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageAreaThreshold_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the surface area is below (SeparateFoliageAreaThreshold * AreaOfTheLargestGroupInTheScene) it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the maximum surface area means everything will be foliage. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the surface area is below (SeparateFoliageAreaThreshold * AreaOfTheLargestGroupInTheScene) it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the maximum surface area means everything will be foliage." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageAreaThreshold = { "SeparateFoliageAreaThreshold", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFoliageSettings, SeparateFoliageAreaThreshold), METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageAreaThreshold_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageAreaThreshold_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageSizeThreshold_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the diameter of the group is below (SeparateFoliageSizeThreshold * SceneDiameter) it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the scene's diameter means everything will be foliage. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Is used to separate the trunk from the foliage in a vegetation scene by finding each group of connected triangles in the scene and if the diameter of the group is below (SeparateFoliageSizeThreshold * SceneDiameter) it is treated as foliage and processed into billboards. The trunk is optimized using reduction. The range is 0->large value. 0 means nothing will be foliage, value larger than the scene's diameter means everything will be foliage." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageSizeThreshold = { "SeparateFoliageSizeThreshold", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFoliageSettings, SeparateFoliageSizeThreshold), METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageSizeThreshold_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageSizeThreshold_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_TrunkReductionRatio_MetaData[] = {
		{ "Category", "FoliageSettings" },
		{ "Comment", "/** Determines the triangle reduction ratio for the trunk part that has been separated from the foliage part based on the 'separate foliage' settings. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines the triangle reduction ratio for the trunk part that has been separated from the foliage part based on the 'separate foliage' settings." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_TrunkReductionRatio = { "TrunkReductionRatio", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FFoliageSettings, TrunkReductionRatio), METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_TrunkReductionRatio_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_TrunkReductionRatio_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FFoliageSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateTrunkAndFoliage,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleRatio,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageTriangleThreshold,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageAreaThreshold,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_SeparateFoliageSizeThreshold,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FFoliageSettings_Statics::NewProp_TrunkReductionRatio,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FFoliageSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"FoliageSettings",
		sizeof(FFoliageSettings),
		alignof(FFoliageSettings),
		Z_Construct_UScriptStruct_FFoliageSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FFoliageSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FFoliageSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FFoliageSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FFoliageSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("FoliageSettings"), sizeof(FFoliageSettings), Get_Z_Construct_UScriptStruct_FFoliageSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FFoliageSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FFoliageSettings_Hash() { return 2956888429U; }
class UScriptStruct* FGenerateLightmapTexCoordSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("GenerateLightmapTexCoordSettings"), sizeof(FGenerateLightmapTexCoordSettings), Get_Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FGenerateLightmapTexCoordSettings>()
{
	return FGenerateLightmapTexCoordSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FGenerateLightmapTexCoordSettings(FGenerateLightmapTexCoordSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("GenerateLightmapTexCoordSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGenerateLightmapTexCoordSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGenerateLightmapTexCoordSettings()
	{
		UScriptStruct::DeferCppStructOps<FGenerateLightmapTexCoordSettings>(FName(TEXT("GenerateLightmapTexCoordSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFGenerateLightmapTexCoordSettings;
	struct Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateLightmapTexCoord_MetaData[];
#endif
		static void NewProp_GenerateLightmapTexCoord_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateLightmapTexCoord;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LightmapTexCoordLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_LightmapTexCoordLevel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LightmapTexCoordName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_LightmapTexCoordName;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ChartAggregatorMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ChartAggregatorMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ChartAggregatorMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TextureWidth_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TextureWidth;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TextureHeight_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TextureHeight;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GutterSpace_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_GutterSpace;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FGenerateLightmapTexCoordSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** Property for whether to generate an extra set of TexCoords for LightMapping. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Property for whether to generate an extra set of TexCoords for LightMapping." },
	};
#endif
	void Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord_SetBit(void* Obj)
	{
		((FGenerateLightmapTexCoordSettings*)Obj)->GenerateLightmapTexCoord = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord = { "GenerateLightmapTexCoord", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FGenerateLightmapTexCoordSettings), &Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordLevel_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** The texture coordinate level used for storing the LightMap UVs. The texcoord name has priority over level. If neither name or level is set then output would be level 0. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The texture coordinate level used for storing the LightMap UVs. The texcoord name has priority over level. If neither name or level is set then output would be level 0." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordLevel = { "LightmapTexCoordLevel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, LightmapTexCoordLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordLevel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordName_MetaData[] = {
		{ "Comment", "/** The texture coordinate level name used for storing the generated Lightmap UVs. If this is not set will default to level. If neither name or level is set then output would be level 0. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The texture coordinate level name used for storing the generated Lightmap UVs. If this is not set will default to level. If neither name or level is set then output would be level 0." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordName = { "LightmapTexCoordName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, LightmapTexCoordName), METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordName_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in.');. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in.');." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode = { "ChartAggregatorMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, ChartAggregatorMode), Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureWidth_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** The width of the texture of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The width of the texture of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureWidth = { "TextureWidth", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, TextureWidth), METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureWidth_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureWidth_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureHeight_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** The height of the texture of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The height of the texture of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureHeight = { "TextureHeight", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, TextureHeight), METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureHeight_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureHeight_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GutterSpace_MetaData[] = {
		{ "Category", "GenerateLightmapTexCoordSettings" },
		{ "Comment", "/** The minimum number of pixels between charts of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The minimum number of pixels between charts of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GutterSpace = { "GutterSpace", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGenerateLightmapTexCoordSettings, GutterSpace), METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GutterSpace_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GutterSpace_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GenerateLightmapTexCoord,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_LightmapTexCoordName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_ChartAggregatorMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureWidth,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_TextureHeight,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::NewProp_GutterSpace,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"GenerateLightmapTexCoordSettings",
		sizeof(FGenerateLightmapTexCoordSettings),
		alignof(FGenerateLightmapTexCoordSettings),
		Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("GenerateLightmapTexCoordSettings"), sizeof(FGenerateLightmapTexCoordSettings), Get_Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FGenerateLightmapTexCoordSettings_Hash() { return 4207716821U; }
class UScriptStruct* FAggregationSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FAggregationSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FAggregationSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("AggregationSettings"), sizeof(FAggregationSettings), Get_Z_Construct_UScriptStruct_FAggregationSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FAggregationSettings>()
{
	return FAggregationSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FAggregationSettings(FAggregationSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("AggregationSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationSettings()
	{
		UScriptStruct::DeferCppStructOps<FAggregationSettings>(FName(TEXT("AggregationSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFAggregationSettings;
	struct Z_Construct_UScriptStruct_FAggregationSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MergeGeometries_MetaData[];
#endif
		static void NewProp_MergeGeometries_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_MergeGeometries;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ProcessSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_ProcessSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_KeepUnprocessedSceneMeshes_MetaData[];
#endif
		static void NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_KeepUnprocessedSceneMeshes;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_EnableGeometryCulling_MetaData[];
#endif
		static void NewProp_EnableGeometryCulling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_EnableGeometryCulling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryCullingPrecision_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GeometryCullingPrecision;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SubdivideGeometryBasedOnUVTiles_MetaData[];
#endif
		static void NewProp_SubdivideGeometryBasedOnUVTiles_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_SubdivideGeometryBasedOnUVTiles;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SubdivisionTileSize_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_SubdivisionTileSize;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FAggregationSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** The processor will merge all the geometries in the scene into a single geometry if this is enabled. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The processor will merge all the geometries in the scene into a single geometry if this is enabled." },
	};
#endif
	void Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries_SetBit(void* Obj)
	{
		((FAggregationSettings*)Obj)->MergeGeometries = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries = { "MergeGeometries", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAggregationSettings), &Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetID_MetaData[] = {
		{ "Comment", "/** Which SelectionSet should be processed. If set to -1, all geometries in the scene will be processed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which SelectionSet should be processed. If set to -1, all geometries in the scene will be processed." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetID = { "ProcessSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationSettings, ProcessSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetName_MetaData[] = {
		{ "Comment", "/** Which selection set should be processed. If the selection set is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which selection set should be processed. If the selection set is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetName = { "ProcessSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationSettings, ProcessSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** If false, the processor will remove all geometry and scene meshes which were not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated, while the rest of the scene tree is kept intact. New geometry is always added as the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If false, the processor will remove all geometry and scene meshes which were not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated, while the rest of the scene tree is kept intact. New geometry is always added as the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones." },
	};
#endif
	void Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj)
	{
		((FAggregationSettings*)Obj)->KeepUnprocessedSceneMeshes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes = { "KeepUnprocessedSceneMeshes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAggregationSettings), &Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** Enables culling object insides and permits use of GeometryCullingSettings. If both this and visibility related culling is enabled, this is run first, then visibility. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enables culling object insides and permits use of GeometryCullingSettings. If both this and visibility related culling is enabled, this is run first, then visibility." },
	};
#endif
	void Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling_SetBit(void* Obj)
	{
		((FAggregationSettings*)Obj)->EnableGeometryCulling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling = { "EnableGeometryCulling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAggregationSettings), &Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_GeometryCullingPrecision_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** The accuracy of the triangle intersection math to find and cull insides used by the EnableTriangleCulling setting. Defined from 0 to 1 where 0 is max speed and 1 is max precision. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The accuracy of the triangle intersection math to find and cull insides used by the EnableTriangleCulling setting. Defined from 0 to 1 where 0 is max speed and 1 is max precision." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_GeometryCullingPrecision = { "GeometryCullingPrecision", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationSettings, GeometryCullingPrecision), METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_GeometryCullingPrecision_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_GeometryCullingPrecision_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** Subdivides the geometry based on the tiling texture coords. The cutting frequency 'SubdivisionTileSize' is a positive integer multiplier (i.e. the mesh will be cut each time its U or V texcoords crosses the SubdivisionTileSize). The output UVs will be in the range [(0,0),(SubdivisionTileSize,SubdivisionTileSize)]. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Subdivides the geometry based on the tiling texture coords. The cutting frequency 'SubdivisionTileSize' is a positive integer multiplier (i.e. the mesh will be cut each time its U or V texcoords crosses the SubdivisionTileSize). The output UVs will be in the range [(0,0),(SubdivisionTileSize,SubdivisionTileSize)]." },
	};
#endif
	void Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles_SetBit(void* Obj)
	{
		((FAggregationSettings*)Obj)->SubdivideGeometryBasedOnUVTiles = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles = { "SubdivideGeometryBasedOnUVTiles", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FAggregationSettings), &Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivisionTileSize_MetaData[] = {
		{ "Category", "AggregationSettings" },
		{ "Comment", "/** The cutting frequency used when SubdivideGeometryBasedOnUVTiles is enabled. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The cutting frequency used when SubdivideGeometryBasedOnUVTiles is enabled." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivisionTileSize = { "SubdivisionTileSize", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FAggregationSettings, SubdivisionTileSize), METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivisionTileSize_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivisionTileSize_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FAggregationSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_MergeGeometries,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_ProcessSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_KeepUnprocessedSceneMeshes,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_EnableGeometryCulling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_GeometryCullingPrecision,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivideGeometryBasedOnUVTiles,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FAggregationSettings_Statics::NewProp_SubdivisionTileSize,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FAggregationSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"AggregationSettings",
		sizeof(FAggregationSettings),
		alignof(FAggregationSettings),
		Z_Construct_UScriptStruct_FAggregationSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FAggregationSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FAggregationSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FAggregationSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FAggregationSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("AggregationSettings"), sizeof(FAggregationSettings), Get_Z_Construct_UScriptStruct_FAggregationSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FAggregationSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FAggregationSettings_Hash() { return 2795315469U; }
class UScriptStruct* FGeometryCullingSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FGeometryCullingSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FGeometryCullingSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("GeometryCullingSettings"), sizeof(FGeometryCullingSettings), Get_Z_Construct_UScriptStruct_FGeometryCullingSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FGeometryCullingSettings>()
{
	return FGeometryCullingSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FGeometryCullingSettings(FGeometryCullingSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("GeometryCullingSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryCullingSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryCullingSettings()
	{
		UScriptStruct::DeferCppStructOps<FGeometryCullingSettings>(FName(TEXT("GeometryCullingSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFGeometryCullingSettings;
	struct Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseClippingPlanes_MetaData[];
#endif
		static void NewProp_UseClippingPlanes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseClippingPlanes;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ClippingPlaneSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ClippingPlaneSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ClippingPlaneSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_ClippingPlaneSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseClippingGeometry_MetaData[];
#endif
		static void NewProp_UseClippingGeometry_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseClippingGeometry;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ClippingGeometrySelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ClippingGeometrySelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ClippingGeometrySelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_ClippingGeometrySelectionSetName;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FGeometryCullingSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes_MetaData[] = {
		{ "Category", "GeometryCullingSettings" },
		{ "Comment", "/** If true the ScenePlanes in the input scene (or the planes selected by the selection set settings) will be used to clip the mesh. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If true the ScenePlanes in the input scene (or the planes selected by the selection set settings) will be used to clip the mesh." },
	};
#endif
	void Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes_SetBit(void* Obj)
	{
		((FGeometryCullingSettings*)Obj)->UseClippingPlanes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes = { "UseClippingPlanes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FGeometryCullingSettings), &Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetID_MetaData[] = {
		{ "Comment", "/** Which SelectionSet containing sceneplanes will be used for clipping. Set name is prioritized over id if both are set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which SelectionSet containing sceneplanes will be used for clipping. Set name is prioritized over id if both are set." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetID = { "ClippingPlaneSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryCullingSettings, ClippingPlaneSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetName_MetaData[] = {
		{ "Comment", "/** Which SelectionSet containing sceneplanes will be used for clipping. Set name is prioritized over id if both are set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which SelectionSet containing sceneplanes will be used for clipping. Set name is prioritized over id if both are set." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetName = { "ClippingPlaneSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryCullingSettings, ClippingPlaneSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry_MetaData[] = {
		{ "Category", "GeometryCullingSettings" },
		{ "Comment", "/** If set, the geometries defined in the matching selection set will be used to clip the process geometry. What side of the geometry that will be culled is determined by the triangle facing, so make sure your winding is correct and that triangles point 'up' toward the space you want to keep. Inconsistent triangle winding or meshes that do not have a clear local inside and outside will cause inconsistent results when used as clipping geometries. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the geometries defined in the matching selection set will be used to clip the process geometry. What side of the geometry that will be culled is determined by the triangle facing, so make sure your winding is correct and that triangles point 'up' toward the space you want to keep. Inconsistent triangle winding or meshes that do not have a clear local inside and outside will cause inconsistent results when used as clipping geometries." },
	};
#endif
	void Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry_SetBit(void* Obj)
	{
		((FGeometryCullingSettings*)Obj)->UseClippingGeometry = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry = { "UseClippingGeometry", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FGeometryCullingSettings), &Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetID_MetaData[] = {
		{ "Comment", "/** Which SelectionSet containing geometries will be used for clipping. Set name is prioritized over id if both are set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which SelectionSet containing geometries will be used for clipping. Set name is prioritized over id if both are set." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetID = { "ClippingGeometrySelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryCullingSettings, ClippingGeometrySelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetName_MetaData[] = {
		{ "Comment", "/** Which SelectionSet containing geometries will be used for clipping. Set name is prioritized over id if both are set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which SelectionSet containing geometries will be used for clipping. Set name is prioritized over id if both are set." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetName = { "ClippingGeometrySelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FGeometryCullingSettings, ClippingGeometrySelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetName_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingPlanes,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingPlaneSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_UseClippingGeometry,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::NewProp_ClippingGeometrySelectionSetName,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"GeometryCullingSettings",
		sizeof(FGeometryCullingSettings),
		alignof(FGeometryCullingSettings),
		Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FGeometryCullingSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FGeometryCullingSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("GeometryCullingSettings"), sizeof(FGeometryCullingSettings), Get_Z_Construct_UScriptStruct_FGeometryCullingSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FGeometryCullingSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FGeometryCullingSettings_Hash() { return 1711838255U; }
class UScriptStruct* FRemeshingSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FRemeshingSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FRemeshingSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("RemeshingSettings"), sizeof(FRemeshingSettings), Get_Z_Construct_UScriptStruct_FRemeshingSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FRemeshingSettings>()
{
	return FRemeshingSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FRemeshingSettings(FRemeshingSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("RemeshingSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingSettings()
	{
		UScriptStruct::DeferCppStructOps<FRemeshingSettings>(FName(TEXT("RemeshingSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFRemeshingSettings;
	struct Z_Construct_UScriptStruct_FRemeshingSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemeshingModeManualPositionZ_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_RemeshingModeManualPositionZ;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemeshingModeManualPositionY_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_RemeshingModeManualPositionY;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemeshingModeManualPositionX_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_RemeshingModeManualPositionX;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OnScreenSize_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_OnScreenSize;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_HoleFilling_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HoleFilling_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_HoleFilling;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_RemeshingMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemeshingMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_RemeshingMode;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_SurfaceTransferMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SurfaceTransferMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_SurfaceTransferMode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HardEdgeAngle_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_HardEdgeAngle;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ForceSoftEdgesWithinTextureCharts_MetaData[];
#endif
		static void NewProp_ForceSoftEdgesWithinTextureCharts_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ForceSoftEdgesWithinTextureCharts;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TransferNormals_MetaData[];
#endif
		static void NewProp_TransferNormals_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_TransferNormals;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TransferColors_MetaData[];
#endif
		static void NewProp_TransferColors_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_TransferColors;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ProcessSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_ProcessSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_KeepUnprocessedSceneMeshes_MetaData[];
#endif
		static void NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_KeepUnprocessedSceneMeshes;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRemeshingSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionZ_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** Z component was a 3-tuple real that acts as the marker designating remeshing processors starting position */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Z component was a 3-tuple real that acts as the marker designating remeshing processors starting position" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionZ = { "RemeshingModeManualPositionZ", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, RemeshingModeManualPositionZ), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionZ_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionZ_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionY_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** Y component was a 3-tuple real that acts as the marker designating remeshing processors starting position */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Y component was a 3-tuple real that acts as the marker designating remeshing processors starting position" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionY = { "RemeshingModeManualPositionY", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, RemeshingModeManualPositionY), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionY_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionY_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionX_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** X component was a 3-tuple real that acts as the marker designating remeshing processors starting position */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "X component was a 3-tuple real that acts as the marker designating remeshing processors starting position" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionX = { "RemeshingModeManualPositionX", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, RemeshingModeManualPositionX), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionX_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionX_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_OnScreenSize_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** The on-screen rendering size of the geometry. Allowed values are in the range 20 to 10000 pixels. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The on-screen rendering size of the geometry. Allowed values are in the range 20 to 10000 pixels." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_OnScreenSize = { "OnScreenSize", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, OnScreenSize), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_OnScreenSize_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_OnScreenSize_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** HoleFilling defines how aggressively the remesher will fill holes and cavities. What this does is to measure the volume and hole opening sizes of concavities in the input geometry and fill them in in the remeshing if the concavity is large enough with a small enough opening. This removes a lot of unnecessary geometry and is recommended to be kept at it's default rather than turning it off, it will in the vast majority of cases have a positive effect on the result. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "HoleFilling defines how aggressively the remesher will fill holes and cavities. What this does is to measure the volume and hole opening sizes of concavities in the input geometry and fill them in in the remeshing if the concavity is large enough with a small enough opening. This removes a lot of unnecessary geometry and is recommended to be kept at it's default rather than turning it off, it will in the vast majority of cases have a positive effect on the result." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling = { "HoleFilling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, HoleFilling), Z_Construct_UEnum_SimplygonUObjects_EHoleFilling, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** The remeshing mode, options are Outside, Inside and Manual. RemeshingMode defines if the remeshing processor remeshes the outside or the inside of the input geometry. Manual needs the user to define a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition. Hole filling only works with the mode Outside. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The remeshing mode, options are Outside, Inside and Manual. RemeshingMode defines if the remeshing processor remeshes the outside or the inside of the input geometry. Manual needs the user to define a position in space that will be considered as outside for the purposes of the remeshing. Position is set with RemeshingModeManualPosition. Hole filling only works with the mode Outside." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode = { "RemeshingMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, RemeshingMode), Z_Construct_UEnum_SimplygonUObjects_ERemeshingMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** The surface transfer mode. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The surface transfer mode." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode = { "SurfaceTransferMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, SurfaceTransferMode), Z_Construct_UEnum_SimplygonUObjects_ESurfaceTransferMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HardEdgeAngle_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** The normal hard angle cutoff in degrees. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The normal hard angle cutoff in degrees." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HardEdgeAngle = { "HardEdgeAngle", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, HardEdgeAngle), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HardEdgeAngle_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HardEdgeAngle_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** If the flag is set, the normal calculation will only allow hard edges along texture borders. Any vertex normal within a texture chart (not along the border) will be forced soft. Caveat: If this is enabled, some normals might be highly interpolated, and deviate substantially from the triangle normal. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If the flag is set, the normal calculation will only allow hard edges along texture borders. Any vertex normal within a texture chart (not along the border) will be forced soft. Caveat: If this is enabled, some normals might be highly interpolated, and deviate substantially from the triangle normal." },
	};
#endif
	void Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts_SetBit(void* Obj)
	{
		((FRemeshingSettings*)Obj)->ForceSoftEdgesWithinTextureCharts = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts = { "ForceSoftEdgesWithinTextureCharts", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRemeshingSettings), &Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** If set, the vertex normals channel will be sampled from the original mesh. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the vertex normals channel will be sampled from the original mesh." },
	};
#endif
	void Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals_SetBit(void* Obj)
	{
		((FRemeshingSettings*)Obj)->TransferNormals = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals = { "TransferNormals", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRemeshingSettings), &Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** If set, vertex color channels will be sampled from the original mesh. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, vertex color channels will be sampled from the original mesh." },
	};
#endif
	void Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors_SetBit(void* Obj)
	{
		((FRemeshingSettings*)Obj)->TransferColors = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors = { "TransferColors", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRemeshingSettings), &Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetID_MetaData[] = {
		{ "Comment", "/** Selects which SelectionSet should be processed. If set to -1, all geometries in the scene will be processed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Selects which SelectionSet should be processed. If set to -1, all geometries in the scene will be processed." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetID = { "ProcessSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, ProcessSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetName_MetaData[] = {
		{ "Comment", "/** Selects which selection set should be processed. If the selection set is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Selects which selection set should be processed. If the selection set is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetName = { "ProcessSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRemeshingSettings, ProcessSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData[] = {
		{ "Category", "RemeshingSettings" },
		{ "Comment", "/** If false, the processor will remove all geometry and scene nodes which was not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated. If old nodes are kept and a new geometry is added to the scene, it will always be the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If false, the processor will remove all geometry and scene nodes which was not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated. If old nodes are kept and a new geometry is added to the scene, it will always be the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones." },
	};
#endif
	void Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj)
	{
		((FRemeshingSettings*)Obj)->KeepUnprocessedSceneMeshes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes = { "KeepUnprocessedSceneMeshes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRemeshingSettings), &Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRemeshingSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionZ,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionY,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingModeManualPositionX,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_OnScreenSize,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HoleFilling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_RemeshingMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_SurfaceTransferMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_HardEdgeAngle,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ForceSoftEdgesWithinTextureCharts,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferNormals,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_TransferColors,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_ProcessSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRemeshingSettings_Statics::NewProp_KeepUnprocessedSceneMeshes,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRemeshingSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"RemeshingSettings",
		sizeof(FRemeshingSettings),
		alignof(FRemeshingSettings),
		Z_Construct_UScriptStruct_FRemeshingSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRemeshingSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FRemeshingSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FRemeshingSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("RemeshingSettings"), sizeof(FRemeshingSettings), Get_Z_Construct_UScriptStruct_FRemeshingSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FRemeshingSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FRemeshingSettings_Hash() { return 3766937427U; }
class UScriptStruct* FMappingImageSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FMappingImageSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FMappingImageSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("MappingImageSettings"), sizeof(FMappingImageSettings), Get_Z_Construct_UScriptStruct_FMappingImageSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FMappingImageSettings>()
{
	return FMappingImageSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FMappingImageSettings(FMappingImageSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("MappingImageSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFMappingImageSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFMappingImageSettings()
	{
		UScriptStruct::DeferCppStructOps<FMappingImageSettings>(FName(TEXT("MappingImageSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFMappingImageSettings;
	struct Z_Construct_UScriptStruct_FMappingImageSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateMappingImage_MetaData[];
#endif
		static void NewProp_GenerateMappingImage_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateMappingImage;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateTexCoords_MetaData[];
#endif
		static void NewProp_GenerateTexCoords_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateTexCoords;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateTangents_MetaData[];
#endif
		static void NewProp_GenerateTangents_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateTangents;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_InputMaterialCount_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_InputMaterialCount;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseFullRetexturing_MetaData[];
#endif
		static void NewProp_UseFullRetexturing_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseFullRetexturing;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ApplyNewMaterialIds_MetaData[];
#endif
		static void NewProp_ApplyNewMaterialIds_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ApplyNewMaterialIds;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputMaterialCount_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_OutputMaterialCount;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReplaceMappingImages_MetaData[];
#endif
		static void NewProp_ReplaceMappingImages_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReplaceMappingImages;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaximumLayers_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_MaximumLayers;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_AllowTransparencyMapping_MetaData[];
#endif
		static void NewProp_AllowTransparencyMapping_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_AllowTransparencyMapping;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseAutomaticTextureSize_MetaData[];
#endif
		static void NewProp_UseAutomaticTextureSize_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseAutomaticTextureSize;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_AutomaticTextureSizeMultiplier_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_AutomaticTextureSizeMultiplier;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ForcePower2Texture_MetaData[];
#endif
		static void NewProp_ForcePower2Texture_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ForcePower2Texture;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OnlyParameterizeInvalidUVs_MetaData[];
#endif
		static void NewProp_OnlyParameterizeInvalidUVs_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_OnlyParameterizeInvalidUVs;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TexCoordLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TexCoordLevel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TexCoordName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_TexCoordName;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_TexCoordGeneratorType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TexCoordGeneratorType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_TexCoordGeneratorType;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_InputMaterialSettings_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_InputMaterialSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_InputMaterialSettings;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_OutputMaterialSettings_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutputMaterialSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_OutputMaterialSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ChartAggregatorSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ChartAggregatorSettings;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ParameterizerSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ParameterizerSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FMappingImageSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage_MetaData[] = {
		{ "Comment", "/** If set, the aggregation processor, reduction processor, or remeshing processor will create a mapping image that maps triangles on the reduced geometry back to triangles on the original geometry. The texture is insert into the MappingImage object. The image data will contain two fields: * RidArray, 'TriangleIds', TupleSize:1, The id of the triangle  * UnsignedShortArray, 'BarycentricCoords', TupleSize:2, Items A & B of the barycentric coordinate on the triangle. The user can control the size of the mapped texture using the values MappingTextureWidth and MappingTextureHeight. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the aggregation processor, reduction processor, or remeshing processor will create a mapping image that maps triangles on the reduced geometry back to triangles on the original geometry. The texture is insert into the MappingImage object. The image data will contain two fields: * RidArray, 'TriangleIds', TupleSize:1, The id of the triangle  * UnsignedShortArray, 'BarycentricCoords', TupleSize:2, Items A & B of the barycentric coordinate on the triangle. The user can control the size of the mapped texture using the values MappingTextureWidth and MappingTextureHeight." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->GenerateMappingImage = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage = { "GenerateMappingImage", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords_MetaData[] = {
		{ "Comment", "/** If true, generates a new texcoords field at the position specified by TexCoordLevel. Will be ignored and always generate texcoords if none are available in the Geometry if GenerateMappingImage is enabled. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If true, generates a new texcoords field at the position specified by TexCoordLevel. Will be ignored and always generate texcoords if none are available in the Geometry if GenerateMappingImage is enabled." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->GenerateTexCoords = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords = { "GenerateTexCoords", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents_MetaData[] = {
		{ "Comment", "/** If true, generates a new tangent space fields at position specified by TexCoordLevel, based on the vertex normals and texture coordinates. Tangent space fields will always be created if missing, and GenerateMappingImage is enabled. If GenerateTexCoords is enabled, new tangents will always be generated. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If true, generates a new tangent space fields at position specified by TexCoordLevel, based on the vertex normals and texture coordinates. Tangent space fields will always be created if missing, and GenerateMappingImage is enabled. If GenerateTexCoords is enabled, new tangents will always be generated." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->GenerateTangents = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents = { "GenerateTangents", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialCount_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** The number of input materials used in the original geometry for mapping to multiple output materials. This needs to be set before you can set any specific in-out material mapping. 0 signifies that no in-out material mapping is used, ie. the process will produce one resulting mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The number of input materials used in the original geometry for mapping to multiple output materials. This needs to be set before you can set any specific in-out material mapping. 0 signifies that no in-out material mapping is used, ie. the process will produce one resulting mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialCount = { "InputMaterialCount", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, InputMaterialCount), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialCount_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialCount_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing_MetaData[] = {
		{ "Comment", "/** If set, all original texcoord sets are replaced by a single new one which will be used for the mapping image. This means the output scene will be temporarily invalid before the materialtable has been updated to reflect the new changes. This flag has no effect on the remeshing, which always does a full retexturing. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, all original texcoord sets are replaced by a single new one which will be used for the mapping image. This means the output scene will be temporarily invalid before the materialtable has been updated to reflect the new changes. This flag has no effect on the remeshing, which always does a full retexturing." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->UseFullRetexturing = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing = { "UseFullRetexturing", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds_MetaData[] = {
		{ "Comment", "/** If true, and also generating one or more mapping images for material casting, the material IDs in the process geometry will be updated to reflect the new, not yet cast output materials. This means the output scene will be temporarily invalid before the materialtable has been updated to reflect the new changes. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If true, and also generating one or more mapping images for material casting, the material IDs in the process geometry will be updated to reflect the new, not yet cast output materials. This means the output scene will be temporarily invalid before the materialtable has been updated to reflect the new changes." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->ApplyNewMaterialIds = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds = { "ApplyNewMaterialIds", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialCount_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** The number of output mapping images that are to be generated. If this is set to more than 1, the material mapping also needs to be set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The number of output mapping images that are to be generated. If this is set to more than 1, the material mapping also needs to be set." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialCount = { "OutputMaterialCount", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, OutputMaterialCount), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialCount_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialCount_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** Whether to replace already existing mapping images in the scene. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Whether to replace already existing mapping images in the scene." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->ReplaceMappingImages = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages = { "ReplaceMappingImages", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_MaximumLayers_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** The maximum number of layers in the mapping image. If a remeshed geometry has a lot of transparent triangles, use a higher number to be able to find intersections on the inside of parts of the geometry. This setting only has effect in the remeshing, when running reduction the number of layers is always 1. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The maximum number of layers in the mapping image. If a remeshed geometry has a lot of transparent triangles, use a higher number to be able to find intersections on the inside of parts of the geometry. This setting only has effect in the remeshing, when running reduction the number of layers is always 1." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_MaximumLayers = { "MaximumLayers", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, MaximumLayers), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_MaximumLayers_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_MaximumLayers_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** If true, the remeshing processor will allow mapped transparency in the generated mapping image. This allows material casting where gaps filled by the remeshing processor will be cast as transparent. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If true, the remeshing processor will allow mapped transparency in the generated mapping image. This allows material casting where gaps filled by the remeshing processor will be cast as transparent." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->AllowTransparencyMapping = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping = { "AllowTransparencyMapping", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** The UseAutomaticTextureSize flag. If true, then texture sizes will be computed for the reduced mesh depending on its pixel size on screen. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The UseAutomaticTextureSize flag. If true, then texture sizes will be computed for the reduced mesh depending on its pixel size on screen." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->UseAutomaticTextureSize = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize = { "UseAutomaticTextureSize", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AutomaticTextureSizeMultiplier_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** Texture dimension length multiplier for the automatic texture size. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Texture dimension length multiplier for the automatic texture size." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AutomaticTextureSizeMultiplier = { "AutomaticTextureSizeMultiplier", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, AutomaticTextureSizeMultiplier), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AutomaticTextureSizeMultiplier_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AutomaticTextureSizeMultiplier_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** If automatic_texture_size is enabled, then force the texture sizes to be a power of 2. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If automatic_texture_size is enabled, then force the texture sizes to be a power of 2." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->ForcePower2Texture = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture = { "ForcePower2Texture", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs_MetaData[] = {
		{ "Comment", "/** If enabled, will aggregate all the valid original UVs. If there are invalid original UVs, those parts will receive new parameterized UVs. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If enabled, will aggregate all the valid original UVs. If there are invalid original UVs, those parts will receive new parameterized UVs." },
	};
#endif
	void Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs_SetBit(void* Obj)
	{
		((FMappingImageSettings*)Obj)->OnlyParameterizeInvalidUVs = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs = { "OnlyParameterizeInvalidUVs", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FMappingImageSettings), &Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordLevel_MetaData[] = {
		{ "Comment", "/** The texture coordinate level used for mapping image and texture generation. If the TexCoordName has been set, the TexCoordLevel is not used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The texture coordinate level used for mapping image and texture generation. If the TexCoordName has been set, the TexCoordLevel is not used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordLevel = { "TexCoordLevel", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, TexCoordLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordLevel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordName_MetaData[] = {
		{ "Comment", "/** The texture coordinate level name used for mapping image and texture generation. If new UVs are created, they will replace the old coordinates in the texture channel with the TexCoordName. If no texture level with this name exists. It will be created. If the TexCoordName is not set, the TexCoordLevel (index) will be used instead. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The texture coordinate level name used for mapping image and texture generation. If new UVs are created, they will replace the old coordinates in the texture channel with the TexCoordName. If no texture level with this name exists. It will be created. If the TexCoordName is not set, the TexCoordLevel (index) will be used instead." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordName = { "TexCoordName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, TexCoordName), METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordName_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "Comment", "/** Determines which method to use when generating the texture coordinates. Parameterizer generate from scratch based on the geometry. ChartAggregator generate based on the original texture coordinates. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines which method to use when generating the texture coordinates. Parameterizer generate from scratch based on the geometry. ChartAggregator generate based on the original texture coordinates." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType = { "TexCoordGeneratorType", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, TexCoordGeneratorType), Z_Construct_UEnum_SimplygonUObjects_ETexCoordGeneratorType, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType_MetaData)) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings_Inner = { "InputMaterialSettings", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FInputMaterialSettings, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings = { "InputMaterialSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, InputMaterialSettings), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings_MetaData)) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings_Inner = { "OutputMaterialSettings", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FOutputMaterialSettings, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings = { "OutputMaterialSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, OutputMaterialSettings), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ChartAggregatorSettings_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ChartAggregatorSettings = { "ChartAggregatorSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, ChartAggregatorSettings), Z_Construct_UScriptStruct_FChartAggregatorSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ChartAggregatorSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ChartAggregatorSettings_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ParameterizerSettings_MetaData[] = {
		{ "Category", "MappingImageSettings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ParameterizerSettings = { "ParameterizerSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FMappingImageSettings, ParameterizerSettings), Z_Construct_UScriptStruct_FParameterizerSettings, METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ParameterizerSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ParameterizerSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FMappingImageSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateMappingImage,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTexCoords,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_GenerateTangents,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialCount,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseFullRetexturing,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ApplyNewMaterialIds,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialCount,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ReplaceMappingImages,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_MaximumLayers,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AllowTransparencyMapping,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_UseAutomaticTextureSize,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_AutomaticTextureSizeMultiplier,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ForcePower2Texture,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OnlyParameterizeInvalidUVs,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_TexCoordGeneratorType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_InputMaterialSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_OutputMaterialSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ChartAggregatorSettings,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FMappingImageSettings_Statics::NewProp_ParameterizerSettings,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FMappingImageSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"MappingImageSettings",
		sizeof(FMappingImageSettings),
		alignof(FMappingImageSettings),
		Z_Construct_UScriptStruct_FMappingImageSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FMappingImageSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FMappingImageSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FMappingImageSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("MappingImageSettings"), sizeof(FMappingImageSettings), Get_Z_Construct_UScriptStruct_FMappingImageSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FMappingImageSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FMappingImageSettings_Hash() { return 3966741U; }
class UScriptStruct* FParameterizerSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FParameterizerSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FParameterizerSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ParameterizerSettings"), sizeof(FParameterizerSettings), Get_Z_Construct_UScriptStruct_FParameterizerSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FParameterizerSettings>()
{
	return FParameterizerSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FParameterizerSettings(FParameterizerSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ParameterizerSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFParameterizerSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFParameterizerSettings()
	{
		UScriptStruct::DeferCppStructOps<FParameterizerSettings>(FName(TEXT("ParameterizerSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFParameterizerSettings;
	struct Z_Construct_UScriptStruct_FParameterizerSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaxStretch_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MaxStretch;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LargeChartsImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_LargeChartsImportance;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FParameterizerSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FParameterizerSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_MaxStretch_MetaData[] = {
		{ "Category", "ParameterizerSettings" },
		{ "Comment", "/** Only used when the TexCoordGeneratorType is Parameterizer. The maximum allowed texture stretch. Range 0->1. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is Parameterizer. The maximum allowed texture stretch. Range 0->1." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_MaxStretch = { "MaxStretch", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FParameterizerSettings, MaxStretch), METADATA_PARAMS(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_MaxStretch_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_MaxStretch_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_LargeChartsImportance_MetaData[] = {
		{ "Category", "ParameterizerSettings" },
		{ "Comment", "/** Only used when the TexCoordGeneratorType is Parameterizer. The importance value for trying to have as large and few charts as possible. The closer the value is to 1, the slower it is. Having 0 means no extra focus will be put on reducing the number of charts. Having value 1 means maximum focus will be put on reducing the number of charts and thereby increasing the size of the charts. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is Parameterizer. The importance value for trying to have as large and few charts as possible. The closer the value is to 1, the slower it is. Having 0 means no extra focus will be put on reducing the number of charts. Having value 1 means maximum focus will be put on reducing the number of charts and thereby increasing the size of the charts." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_LargeChartsImportance = { "LargeChartsImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FParameterizerSettings, LargeChartsImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_LargeChartsImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_LargeChartsImportance_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FParameterizerSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_MaxStretch,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FParameterizerSettings_Statics::NewProp_LargeChartsImportance,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FParameterizerSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"ParameterizerSettings",
		sizeof(FParameterizerSettings),
		alignof(FParameterizerSettings),
		Z_Construct_UScriptStruct_FParameterizerSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FParameterizerSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FParameterizerSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FParameterizerSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ParameterizerSettings"), sizeof(FParameterizerSettings), Get_Z_Construct_UScriptStruct_FParameterizerSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FParameterizerSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FParameterizerSettings_Hash() { return 1668003239U; }
class UScriptStruct* FChartAggregatorSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FChartAggregatorSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FChartAggregatorSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ChartAggregatorSettings"), sizeof(FChartAggregatorSettings), Get_Z_Construct_UScriptStruct_FChartAggregatorSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FChartAggregatorSettings>()
{
	return FChartAggregatorSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FChartAggregatorSettings(FChartAggregatorSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ChartAggregatorSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFChartAggregatorSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFChartAggregatorSettings()
	{
		UScriptStruct::DeferCppStructOps<FChartAggregatorSettings>(FName(TEXT("ChartAggregatorSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFChartAggregatorSettings;
	struct Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ChartAggregatorMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ChartAggregatorMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ChartAggregatorMode;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_SurfaceAreaScale_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SurfaceAreaScale_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_SurfaceAreaScale;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OriginalTexCoordLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_OriginalTexCoordLevel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OriginalTexCoordName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OriginalTexCoordName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SeparateOverlappingCharts_MetaData[];
#endif
		static void NewProp_SeparateOverlappingCharts_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_SeparateOverlappingCharts;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OriginalChartProportionsChannel_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OriginalChartProportionsChannel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LockUVRotation_MetaData[];
#endif
		static void NewProp_LockUVRotation_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_LockUVRotation;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FChartAggregatorSettings>();
	}
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode_MetaData[] = {
		{ "Category", "ChartAggregatorSettings" },
		{ "Comment", "/** Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Determines which method to use when aggregating the UVs. TextureSizeProportions - Aggregated UV charts will be scaled to keep their relative pixel density relative to all other UV charts. The user can still set the size of the output texture maps. SurfaceArea - Aggregated UV charts will have their size set based on its actual geometrical size. OriginalPixelDensity - The combined atlas will be resized to fit each chart so that all charts retain the same amount of pixels as they originally had. This will override any manually set texture size. UVSizeProportions - Aggregated UV charts will have their size set based on its original UV size, disregarding the size of the texture they are used in." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode = { "ChartAggregatorMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FChartAggregatorSettings, ChartAggregatorMode), Z_Construct_UEnum_SimplygonUObjects_EChartAggregatorMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale_MetaData[] = {
		{ "Category", "ChartAggregatorSettings" },
		{ "Comment", "/** If multiple UV charts overlap and have the same material, SurfaceAreaScale specifies which of those instances determines the the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If multiple UV charts overlap and have the same material, SurfaceAreaScale specifies which of those instances determines the the output scale. It is only valid when the ChartAggregatorMode is SurfaceArea and SeparateOverlappingCharts is false." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale = { "SurfaceAreaScale", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FChartAggregatorSettings, SurfaceAreaScale), Z_Construct_UEnum_SimplygonUObjects_ESurfaceAreaScale, METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordLevel_MetaData[] = {
		{ "Comment", "/** Only used when the TexCoordGeneratorType is ChartAggregator. Set the texture coordinate level to get charts from. If the ChartAggregatorOriginalTexCoordName ha been set, the ChartAggregatorOriginalTexCoordLevel is not used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is ChartAggregator. Set the texture coordinate level to get charts from. If the ChartAggregatorOriginalTexCoordName ha been set, the ChartAggregatorOriginalTexCoordLevel is not used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordLevel = { "OriginalTexCoordLevel", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FChartAggregatorSettings, OriginalTexCoordLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordLevel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordName_MetaData[] = {
		{ "Comment", "/** Only used when the TexCoordGeneratorType is ChartAggregator. Set the name of the texture coordinate level to get charts from. If not set, it will use the ChartAggregatorOriginalTexCoordLevel (index) instead. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is ChartAggregator. Set the name of the texture coordinate level to get charts from. If not set, it will use the ChartAggregatorOriginalTexCoordLevel (index) instead." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordName = { "OriginalTexCoordName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FChartAggregatorSettings, OriginalTexCoordName), METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts_MetaData[] = {
		{ "Category", "ChartAggregatorSettings" },
		{ "Comment", "/** Only used when the TexCoordGeneratorType is ChartAggregator. If set, charts that are overlapping in the original texture coords will be separated. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is ChartAggregator. If set, charts that are overlapping in the original texture coords will be separated." },
	};
#endif
	void Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts_SetBit(void* Obj)
	{
		((FChartAggregatorSettings*)Obj)->SeparateOverlappingCharts = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts = { "SeparateOverlappingCharts", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FChartAggregatorSettings), &Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalChartProportionsChannel_MetaData[] = {
		{ "Comment", "/** Only used when the TexCoordGeneratorType is ChartAggregator. Set ChartAggregatorKeepOriginalChartProportionsFromChannel to an SG_MATERIAL_CHANNEL_[...]. This channel determines which texture channel to look at when determining which chart proportions to keep. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is ChartAggregator. Set ChartAggregatorKeepOriginalChartProportionsFromChannel to an SG_MATERIAL_CHANNEL_[...]. This channel determines which texture channel to look at when determining which chart proportions to keep." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalChartProportionsChannel = { "OriginalChartProportionsChannel", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FChartAggregatorSettings, OriginalChartProportionsChannel), METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalChartProportionsChannel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalChartProportionsChannel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation_MetaData[] = {
		{ "Category", "ChartAggregatorSettings" },
		{ "Comment", "/** Only used when the TexCoordGeneratorType is ChartAggregator. If ChartAggregatorLockUVRotation is enabled, only the original UV rotation will be used. Otherwise 4 rotations are used (90 degree rotations). */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Only used when the TexCoordGeneratorType is ChartAggregator. If ChartAggregatorLockUVRotation is enabled, only the original UV rotation will be used. Otherwise 4 rotations are used (90 degree rotations)." },
	};
#endif
	void Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation_SetBit(void* Obj)
	{
		((FChartAggregatorSettings*)Obj)->LockUVRotation = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation = { "LockUVRotation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FChartAggregatorSettings), &Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_ChartAggregatorMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SurfaceAreaScale,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalTexCoordName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_SeparateOverlappingCharts,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_OriginalChartProportionsChannel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::NewProp_LockUVRotation,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"ChartAggregatorSettings",
		sizeof(FChartAggregatorSettings),
		alignof(FChartAggregatorSettings),
		Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FChartAggregatorSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FChartAggregatorSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ChartAggregatorSettings"), sizeof(FChartAggregatorSettings), Get_Z_Construct_UScriptStruct_FChartAggregatorSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FChartAggregatorSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FChartAggregatorSettings_Hash() { return 2901660146U; }
class UScriptStruct* FOutputMaterialSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FOutputMaterialSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FOutputMaterialSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("OutputMaterialSettings"), sizeof(FOutputMaterialSettings), Get_Z_Construct_UScriptStruct_FOutputMaterialSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FOutputMaterialSettings>()
{
	return FOutputMaterialSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FOutputMaterialSettings(FOutputMaterialSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("OutputMaterialSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFOutputMaterialSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFOutputMaterialSettings()
	{
		UScriptStruct::DeferCppStructOps<FOutputMaterialSettings>(FName(TEXT("OutputMaterialSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFOutputMaterialSettings;
	struct Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TextureWidth_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TextureWidth;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TextureHeight_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TextureHeight;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MultisamplingLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_MultisamplingLevel;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GutterSpace_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_GutterSpace;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FOutputMaterialSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureWidth_MetaData[] = {
		{ "Category", "OutputMaterialSettings" },
		{ "Comment", "/** The width of the texture of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The width of the texture of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureWidth = { "TextureWidth", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOutputMaterialSettings, TextureWidth), METADATA_PARAMS(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureWidth_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureWidth_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureHeight_MetaData[] = {
		{ "Category", "OutputMaterialSettings" },
		{ "Comment", "/** The height of the texture of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The height of the texture of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureHeight = { "TextureHeight", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOutputMaterialSettings, TextureHeight), METADATA_PARAMS(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureHeight_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureHeight_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_MultisamplingLevel_MetaData[] = {
		{ "Category", "OutputMaterialSettings" },
		{ "Comment", "/** The multi-sampling level of the output mapping image. Values 1-8 are accepted. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The multi-sampling level of the output mapping image. Values 1-8 are accepted." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_MultisamplingLevel = { "MultisamplingLevel", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOutputMaterialSettings, MultisamplingLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_MultisamplingLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_MultisamplingLevel_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_GutterSpace_MetaData[] = {
		{ "Category", "OutputMaterialSettings" },
		{ "Comment", "/** The minimum number of pixels between charts of the output mapping image. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The minimum number of pixels between charts of the output mapping image." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_GutterSpace = { "GutterSpace", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FOutputMaterialSettings, GutterSpace), METADATA_PARAMS(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_GutterSpace_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_GutterSpace_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureWidth,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_TextureHeight,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_MultisamplingLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::NewProp_GutterSpace,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"OutputMaterialSettings",
		sizeof(FOutputMaterialSettings),
		alignof(FOutputMaterialSettings),
		Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FOutputMaterialSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FOutputMaterialSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("OutputMaterialSettings"), sizeof(FOutputMaterialSettings), Get_Z_Construct_UScriptStruct_FOutputMaterialSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FOutputMaterialSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FOutputMaterialSettings_Hash() { return 2912055722U; }
class UScriptStruct* FInputMaterialSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FInputMaterialSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FInputMaterialSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("InputMaterialSettings"), sizeof(FInputMaterialSettings), Get_Z_Construct_UScriptStruct_FInputMaterialSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FInputMaterialSettings>()
{
	return FInputMaterialSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FInputMaterialSettings(FInputMaterialSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("InputMaterialSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFInputMaterialSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFInputMaterialSettings()
	{
		UScriptStruct::DeferCppStructOps<FInputMaterialSettings>(FName(TEXT("InputMaterialSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFInputMaterialSettings;
	struct Z_Construct_UScriptStruct_FInputMaterialSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialMapping_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_MaterialMapping;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FInputMaterialSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewProp_MaterialMapping_MetaData[] = {
		{ "Category", "InputMaterialSettings" },
		{ "Comment", "/** The material mapping for the input material this setting object corresponds to, meaning what material of the generated LOD the corresponding input material will be baked into. Both InputMaterialCount and OutputMaterialCount need to be set for this mapping to work, and all original materials need to be mapped to an existing output id. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The material mapping for the input material this setting object corresponds to, meaning what material of the generated LOD the corresponding input material will be baked into. Both InputMaterialCount and OutputMaterialCount need to be set for this mapping to work, and all original materials need to be mapped to an existing output id." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewProp_MaterialMapping = { "MaterialMapping", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FInputMaterialSettings, MaterialMapping), METADATA_PARAMS(Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewProp_MaterialMapping_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewProp_MaterialMapping_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::NewProp_MaterialMapping,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"InputMaterialSettings",
		sizeof(FInputMaterialSettings),
		alignof(FInputMaterialSettings),
		Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FInputMaterialSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FInputMaterialSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("InputMaterialSettings"), sizeof(FInputMaterialSettings), Get_Z_Construct_UScriptStruct_FInputMaterialSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FInputMaterialSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FInputMaterialSettings_Hash() { return 2430487093U; }
class UScriptStruct* FVertexWeightSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FVertexWeightSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVertexWeightSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("VertexWeightSettings"), sizeof(FVertexWeightSettings), Get_Z_Construct_UScriptStruct_FVertexWeightSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FVertexWeightSettings>()
{
	return FVertexWeightSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVertexWeightSettings(FVertexWeightSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("VertexWeightSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexWeightSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexWeightSettings()
	{
		UScriptStruct::DeferCppStructOps<FVertexWeightSettings>(FName(TEXT("VertexWeightSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFVertexWeightSettings;
	struct Z_Construct_UScriptStruct_FVertexWeightSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseVertexWeightsInReducer_MetaData[];
#endif
		static void NewProp_UseVertexWeightsInReducer_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseVertexWeightsInReducer;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseVertexWeightsInTexcoordGenerator_MetaData[];
#endif
		static void NewProp_UseVertexWeightsInTexcoordGenerator_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseVertexWeightsInTexcoordGenerator;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeightsFromColorName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_WeightsFromColorName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeightsFromColorLevel_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_WeightsFromColorLevel;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_WeightsFromColorComponent_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeightsFromColorComponent_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_WeightsFromColorComponent;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeightsFromColorMultiplier_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_WeightsFromColorMultiplier;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_WeightsFromColorMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeightsFromColorMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_WeightsFromColorMode;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVertexWeightSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer_MetaData[] = {
		{ "Category", "VertexWeightSettings" },
		{ "Comment", "/** If set, and using the reduction processor, the reduction will be weighted based on the weights in the 'VertexWeights' vertex field. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, and using the reduction processor, the reduction will be weighted based on the weights in the 'VertexWeights' vertex field." },
	};
#endif
	void Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer_SetBit(void* Obj)
	{
		((FVertexWeightSettings*)Obj)->UseVertexWeightsInReducer = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer = { "UseVertexWeightsInReducer", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVertexWeightSettings), &Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator_MetaData[] = {
		{ "Category", "VertexWeightSettings" },
		{ "Comment", "/** If set, and generating new texcoords using either the parameterizeror the chart aggregator, the relative sizes of the output charts will be scaled using the weights in the 'VertexWeights' vertex field. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, and generating new texcoords using either the parameterizeror the chart aggregator, the relative sizes of the output charts will be scaled using the weights in the 'VertexWeights' vertex field." },
	};
#endif
	void Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator_SetBit(void* Obj)
	{
		((FVertexWeightSettings*)Obj)->UseVertexWeightsInTexcoordGenerator = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator = { "UseVertexWeightsInTexcoordGenerator", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVertexWeightSettings), &Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorName_MetaData[] = {
		{ "Comment", "/** If the name of an existing vertex color field in the input geometry is set here, the existing VertexWeights field will be overwritten by a set created by converting the selected color field according to the other WeightsFromColor settings in this settings object. If both ColorName and the corresponding ColorLevel is set, the processors will prioritize the name. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If the name of an existing vertex color field in the input geometry is set here, the existing VertexWeights field will be overwritten by a set created by converting the selected color field according to the other WeightsFromColor settings in this settings object. If both ColorName and the corresponding ColorLevel is set, the processors will prioritize the name." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorName = { "WeightsFromColorName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexWeightSettings, WeightsFromColorName), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorLevel_MetaData[] = {
		{ "Comment", "/** If the index of an existing vertex color field in the input geometry is set here, the existing VertexWeights field will be overwritten by a set created by converting the selected color field according to the other WeightsFromColor settings in this settings object. If both this and the corresponding ColorName is set, the processors will prioritize the name. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If the index of an existing vertex color field in the input geometry is set here, the existing VertexWeights field will be overwritten by a set created by converting the selected color field according to the other WeightsFromColor settings in this settings object. If both this and the corresponding ColorName is set, the processors will prioritize the name." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorLevel = { "WeightsFromColorLevel", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexWeightSettings, WeightsFromColorLevel), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorLevel_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorLevel_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent_MetaData[] = {
		{ "Category", "VertexWeightSettings" },
		{ "Comment", "/** If converting vertex colors to weights, this setting controls which color component is used to create the weights. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If converting vertex colors to weights, this setting controls which color component is used to create the weights." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent = { "WeightsFromColorComponent", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexWeightSettings, WeightsFromColorComponent), Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorComponent, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMultiplier_MetaData[] = {
		{ "Category", "VertexWeightSettings" },
		{ "Comment", "/** If converting vertex colors to weights, this setting controls the max and min resulting vertex weights generated by the input color. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If converting vertex colors to weights, this setting controls the max and min resulting vertex weights generated by the input color." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMultiplier = { "WeightsFromColorMultiplier", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexWeightSettings, WeightsFromColorMultiplier), METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMultiplier_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMultiplier_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode_MetaData[] = {
		{ "Category", "VertexWeightSettings" },
		{ "Comment", "/** If converting vertex colors to weights, this setting along with WeightsFromColorMultiplier controls how to map the RGBA intensity between 0-1 to weights. Standard mode maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]. High mode maps color intensity [0-1] to vertex weight [1 - Multiplier]. Low mode maps color intensity [0-1] to vertex weight [1/Multiplier - 1]. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If converting vertex colors to weights, this setting along with WeightsFromColorMultiplier controls how to map the RGBA intensity between 0-1 to weights. Standard mode maps color intensity [0-1] to vertex weight [1/Multiplier - Multiplier]. High mode maps color intensity [0-1] to vertex weight [1 - Multiplier]. Low mode maps color intensity [0-1] to vertex weight [1/Multiplier - 1]." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode = { "WeightsFromColorMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVertexWeightSettings, WeightsFromColorMode), Z_Construct_UEnum_SimplygonUObjects_EWeightsFromColorMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInReducer,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_UseVertexWeightsInTexcoordGenerator,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorLevel,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorComponent,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMultiplier,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::NewProp_WeightsFromColorMode,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"VertexWeightSettings",
		sizeof(FVertexWeightSettings),
		alignof(FVertexWeightSettings),
		Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVertexWeightSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVertexWeightSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VertexWeightSettings"), sizeof(FVertexWeightSettings), Get_Z_Construct_UScriptStruct_FVertexWeightSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVertexWeightSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVertexWeightSettings_Hash() { return 2875206059U; }
class UScriptStruct* FBoneSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FBoneSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FBoneSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("BoneSettings"), sizeof(FBoneSettings), Get_Z_Construct_UScriptStruct_FBoneSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FBoneSettings>()
{
	return FBoneSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FBoneSettings(FBoneSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("BoneSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBoneSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFBoneSettings()
	{
		UScriptStruct::DeferCppStructOps<FBoneSettings>(FName(TEXT("BoneSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFBoneSettings;
	struct Z_Construct_UScriptStruct_FBoneSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseBoneReducer_MetaData[];
#endif
		static void NewProp_UseBoneReducer_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseBoneReducer;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetBoneRatioEnabled_MetaData[];
#endif
		static void NewProp_BoneReductionTargetBoneRatioEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BoneReductionTargetBoneRatioEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemoveUnusedBones_MetaData[];
#endif
		static void NewProp_RemoveUnusedBones_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_RemoveUnusedBones;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LimitBonesPerVertex_MetaData[];
#endif
		static void NewProp_LimitBonesPerVertex_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_LimitBonesPerVertex;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetBoneCountEnabled_MetaData[];
#endif
		static void NewProp_BoneReductionTargetBoneCountEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BoneReductionTargetBoneCountEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetMaxDeviationEnabled_MetaData[];
#endif
		static void NewProp_BoneReductionTargetMaxDeviationEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BoneReductionTargetMaxDeviationEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaxBonePerVertex_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_MaxBonePerVertex;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetOnScreenSizeEnabled_MetaData[];
#endif
		static void NewProp_BoneReductionTargetOnScreenSizeEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BoneReductionTargetOnScreenSizeEnabled;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_BoneReductionTargetStopCondition_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetStopCondition_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_BoneReductionTargetStopCondition;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetBoneRatio_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_BoneReductionTargetBoneRatio;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetBoneCount_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneReductionTargetBoneCount;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetMaxDeviation_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_BoneReductionTargetMaxDeviation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BoneReductionTargetOnScreenSize_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneReductionTargetOnScreenSize;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LockBoneSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_LockBoneSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LockBoneSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_LockBoneSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemoveBoneSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_RemoveBoneSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemoveBoneSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_RemoveBoneSelectionSetName;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FBoneSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FBoneSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Enables or disables the bone reduction processing that actually removes bones. Even with this flag off, the bones per vertex can still be limited. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enables or disables the bone reduction processing that actually removes bones. Even with this flag off, the bones per vertex can still be limited." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->UseBoneReducer = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer = { "UseBoneReducer", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Enable bone ratio as a reduction target. The reducer will stop when the set bone-ratio has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable bone ratio as a reduction target. The reducer will stop when the set bone-ratio has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->BoneReductionTargetBoneRatioEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled = { "BoneReductionTargetBoneRatioEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Decides whether unused bones should be removed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Decides whether unused bones should be removed." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->RemoveUnusedBones = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones = { "RemoveUnusedBones", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Decides whether unused bones should be removed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Decides whether unused bones should be removed." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->LimitBonesPerVertex = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex = { "LimitBonesPerVertex", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Enable bone count as a reduction target. The reducer will stop when the set bone count has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable bone count as a reduction target. The reducer will stop when the set bone count has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->BoneReductionTargetBoneCountEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled = { "BoneReductionTargetBoneCountEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Enable max deviation as a reduction target. The reducer will stop when the set max deviation has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable max deviation as a reduction target. The reducer will stop when the set max deviation has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->BoneReductionTargetMaxDeviationEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled = { "BoneReductionTargetMaxDeviationEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_MaxBonePerVertex_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Decides the maximum limit of how many bones can be connected to each vertex. If for example set to 1, then each vertex will only be linked to 1 bone. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Decides the maximum limit of how many bones can be connected to each vertex. If for example set to 1, then each vertex will only be linked to 1 bone." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_MaxBonePerVertex = { "MaxBonePerVertex", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, MaxBonePerVertex), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_MaxBonePerVertex_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_MaxBonePerVertex_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** Enable on screen size as a reduction target. The reducer will stop when the set on screen size has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable on screen size as a reduction target. The reducer will stop when the set on screen size has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled_SetBit(void* Obj)
	{
		((FBoneSettings*)Obj)->BoneReductionTargetOnScreenSizeEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled = { "BoneReductionTargetOnScreenSizeEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FBoneSettings), &Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** The stop condition for the bone reducer. Any: the reducer will stop when any single one of the set reduction targets have been reached. All: the reducer will stop when all enabled reduction targets have been set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The stop condition for the bone reducer. Any: the reducer will stop when any single one of the set reduction targets have been reached. All: the reducer will stop when all enabled reduction targets have been set." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition = { "BoneReductionTargetStopCondition", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, BoneReductionTargetStopCondition), Z_Construct_UEnum_SimplygonUObjects_EBoneReductionTargetStopCondition, METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatio_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** The desired bone reduction ratio. The range is 0->1. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The desired bone reduction ratio. The range is 0->1." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatio = { "BoneReductionTargetBoneRatio", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, BoneReductionTargetBoneRatio), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatio_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatio_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCount_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** The desired bone count. The range is 0->inf. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The desired bone count. The range is 0->inf." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCount = { "BoneReductionTargetBoneCount", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, BoneReductionTargetBoneCount), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCount_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCount_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviation_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** The MaxDeviation value, the maximum surface-deviation between the reduced geometry and the original. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The MaxDeviation value, the maximum surface-deviation between the reduced geometry and the original." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviation = { "BoneReductionTargetMaxDeviation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, BoneReductionTargetMaxDeviation), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSize_MetaData[] = {
		{ "Category", "BoneSettings" },
		{ "Comment", "/** The OnScreenSize value, the maximum surface-deviation between the reduced geometry and the original. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The OnScreenSize value, the maximum surface-deviation between the reduced geometry and the original." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSize = { "BoneReductionTargetOnScreenSize", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, BoneReductionTargetOnScreenSize), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSize_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSize_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetID_MetaData[] = {
		{ "Comment", "/** The ID of the selection set that contains all of the bones that will be locked, and cannot be removed in the BoneLOD process. If a bone is locked, all its ancestors will be locked also. If the ID is -1, then no bones are selected. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The ID of the selection set that contains all of the bones that will be locked, and cannot be removed in the BoneLOD process. If a bone is locked, all its ancestors will be locked also. If the ID is -1, then no bones are selected." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetID = { "LockBoneSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, LockBoneSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetName_MetaData[] = {
		{ "Comment", "/** The name of the selection set that contains all of the bones that will be locked, and cannot be removed in the BoneLOD process. If a bone is locked, all its ancestors will be locked also. If both name and id are set for the locked selection set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the selection set that contains all of the bones that will be locked, and cannot be removed in the BoneLOD process. If a bone is locked, all its ancestors will be locked also. If both name and id are set for the locked selection set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetName = { "LockBoneSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, LockBoneSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetID_MetaData[] = {
		{ "Comment", "/** The ID of the selection set that contains all of the bones that will be forced to be removed in the BoneLOD process, UNLESS they are locked. If a bone is set to be removed, all its descendants will be removed also. If both name and id are set for the remove selection set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The ID of the selection set that contains all of the bones that will be forced to be removed in the BoneLOD process, UNLESS they are locked. If a bone is set to be removed, all its descendants will be removed also. If both name and id are set for the remove selection set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetID = { "RemoveBoneSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, RemoveBoneSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetName_MetaData[] = {
		{ "Comment", "/** The name of the selection set that contains all of the bones that will be forced to be removed in the BoneLOD process, UNLESS they are locked. If a bone is set to be removed, all its descendants will be removed also. If both name and id are set for the remove selection set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the selection set that contains all of the bones that will be forced to be removed in the BoneLOD process, UNLESS they are locked. If a bone is set to be removed, all its descendants will be removed also. If both name and id are set for the remove selection set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetName = { "RemoveBoneSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FBoneSettings, RemoveBoneSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetName_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FBoneSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_UseBoneReducer,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatioEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveUnusedBones,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LimitBonesPerVertex,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCountEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviationEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_MaxBonePerVertex,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSizeEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetStopCondition,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneRatio,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetBoneCount,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetMaxDeviation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_BoneReductionTargetOnScreenSize,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_LockBoneSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FBoneSettings_Statics::NewProp_RemoveBoneSelectionSetName,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FBoneSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"BoneSettings",
		sizeof(FBoneSettings),
		alignof(FBoneSettings),
		Z_Construct_UScriptStruct_FBoneSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FBoneSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FBoneSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FBoneSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FBoneSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("BoneSettings"), sizeof(FBoneSettings), Get_Z_Construct_UScriptStruct_FBoneSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FBoneSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FBoneSettings_Hash() { return 1497868596U; }
class UScriptStruct* FVisibilitySettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FVisibilitySettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVisibilitySettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("VisibilitySettings"), sizeof(FVisibilitySettings), Get_Z_Construct_UScriptStruct_FVisibilitySettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FVisibilitySettings>()
{
	return FVisibilitySettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVisibilitySettings(FVisibilitySettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("VisibilitySettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVisibilitySettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFVisibilitySettings()
	{
		UScriptStruct::DeferCppStructOps<FVisibilitySettings>(FName(TEXT("VisibilitySettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFVisibilitySettings;
	struct Z_Construct_UScriptStruct_FVisibilitySettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseVisibilityWeightsInReducer_MetaData[];
#endif
		static void NewProp_UseVisibilityWeightsInReducer_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseVisibilityWeightsInReducer;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseVisibilityWeightsInTexcoordGenerator_MetaData[];
#endif
		static void NewProp_UseVisibilityWeightsInTexcoordGenerator_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseVisibilityWeightsInTexcoordGenerator;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VisibilityWeightsPower_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_VisibilityWeightsPower;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CullOccludedGeometry_MetaData[];
#endif
		static void NewProp_CullOccludedGeometry_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_CullOccludedGeometry;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ForceVisibilityCalculation_MetaData[];
#endif
		static void NewProp_ForceVisibilityCalculation_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ForceVisibilityCalculation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseBackfaceCulling_MetaData[];
#endif
		static void NewProp_UseBackfaceCulling_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseBackfaceCulling;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CameraSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_CameraSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CameraSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_CameraSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OccluderSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_OccluderSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OccluderSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_OccluderSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FillNonVisibleAreaThreshold_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_FillNonVisibleAreaThreshold;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RemoveTrianglesNotOccludingOtherTriangles_MetaData[];
#endif
		static void NewProp_RemoveTrianglesNotOccludingOtherTriangles_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_RemoveTrianglesNotOccludingOtherTriangles;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ConservativeMode_MetaData[];
#endif
		static void NewProp_ConservativeMode_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ConservativeMode;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ComputeVisibilityMode_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ComputeVisibilityMode_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ComputeVisibilityMode;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVisibilitySettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If set to true, visibility weights will be used in the reducer. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set to true, visibility weights will be used in the reducer." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->UseVisibilityWeightsInReducer = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer = { "UseVisibilityWeightsInReducer", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If set to true, visibility weights will be used when generating new texture coordinates. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set to true, visibility weights will be used when generating new texture coordinates." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->UseVisibilityWeightsInTexcoordGenerator = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator = { "UseVisibilityWeightsInTexcoordGenerator", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_VisibilityWeightsPower_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** Set how aggressively reducer should handle low visibility weights. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set how aggressively reducer should handle low visibility weights." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_VisibilityWeightsPower = { "VisibilityWeightsPower", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, VisibilityWeightsPower), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_VisibilityWeightsPower_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_VisibilityWeightsPower_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If set to true, geometry that is not visible will be removed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set to true, geometry that is not visible will be removed." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->CullOccludedGeometry = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry = { "CullOccludedGeometry", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** Set the ForceVisibilityCalculation if true, visibility weights will definitely be computed for the geometry, even if the visibility isn't specifically being used for reduction/materialLOD/culling according to the VisibilitySettings. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set the ForceVisibilityCalculation if true, visibility weights will definitely be computed for the geometry, even if the visibility isn't specifically being used for reduction/materialLOD/culling according to the VisibilitySettings." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->ForceVisibilityCalculation = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation = { "ForceVisibilityCalculation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** Set whether triangles should be regarded visible when viewed from the back. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set whether triangles should be regarded visible when viewed from the back." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->UseBackfaceCulling = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling = { "UseBackfaceCulling", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetID_MetaData[] = {
		{ "Comment", "/** The ID of the selection set containing all the scene cameras and scene meshes used when computing visibility. If scene meshes are added, all their vertices will be used as omni-directional cameras. If set to -1, all cameras in the scene will be used. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The ID of the selection set containing all the scene cameras and scene meshes used when computing visibility. If scene meshes are added, all their vertices will be used as omni-directional cameras. If set to -1, all cameras in the scene will be used. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetID = { "CameraSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, CameraSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetName_MetaData[] = {
		{ "Comment", "/** The name of the selection set containing all the scene cameras and scene meshes used when computing visibility. If scene meshes are added, all their vertices will be used as omni-directional cameras. If set to null, all cameras in the scene will be used. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the selection set containing all the scene cameras and scene meshes used when computing visibility. If scene meshes are added, all their vertices will be used as omni-directional cameras. If set to null, all cameras in the scene will be used. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetName = { "CameraSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, CameraSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetID_MetaData[] = {
		{ "Comment", "/** The ID of the selection set containing all the scene meshes that should occlude the scene when calculating visibility. If set to -1, no occluders will be used. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The ID of the selection set containing all the scene meshes that should occlude the scene when calculating visibility. If set to -1, no occluders will be used. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetID = { "OccluderSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, OccluderSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetName_MetaData[] = {
		{ "Comment", "/** The name of the selection set containing all the scene meshes used when computing visibility. If set to null, no occluders in the scene will be used. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The name of the selection set containing all the scene meshes used when computing visibility. If set to null, no occluders in the scene will be used. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetName = { "OccluderSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, OccluderSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_FillNonVisibleAreaThreshold_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If a group of non-visible triangles (connected to visible triangles) has an area below the FillNonVisibleAreaThreshold - it will receive the same visibility as the neighboring visible triangles. Set to zero to skip filling nonvisible regions. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If a group of non-visible triangles (connected to visible triangles) has an area below the FillNonVisibleAreaThreshold - it will receive the same visibility as the neighboring visible triangles. Set to zero to skip filling nonvisible regions." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_FillNonVisibleAreaThreshold = { "FillNonVisibleAreaThreshold", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, FillNonVisibleAreaThreshold), METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_FillNonVisibleAreaThreshold_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_FillNonVisibleAreaThreshold_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If enabled, will remove all the visible triangles that are not occluding any other triangle. It will also remove all non-visible triangles. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If enabled, will remove all the visible triangles that are not occluding any other triangle. It will also remove all non-visible triangles." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->RemoveTrianglesNotOccludingOtherTriangles = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles = { "RemoveTrianglesNotOccludingOtherTriangles", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** If enabled, will compute the visibility conservatively - meaning that triangles that are visible will be tagged as visible but some non-visible triangles might also be tagged as visible. If this is turned off, then it is no longer guaranteed that all visible triangles are found - but more non-visible triangles will be identified as non-visible. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If enabled, will compute the visibility conservatively - meaning that triangles that are visible will be tagged as visible but some non-visible triangles might also be tagged as visible. If this is turned off, then it is no longer guaranteed that all visible triangles are found - but more non-visible triangles will be identified as non-visible." },
	};
#endif
	void Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode_SetBit(void* Obj)
	{
		((FVisibilitySettings*)Obj)->ConservativeMode = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode = { "ConservativeMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FVisibilitySettings), &Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode_MetaData[] = {
		{ "Category", "VisibilitySettings" },
		{ "Comment", "/** Specifies the renderer type when computing visibility. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Specifies the renderer type when computing visibility." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode = { "ComputeVisibilityMode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVisibilitySettings, ComputeVisibilityMode), Z_Construct_UEnum_SimplygonUObjects_EComputeVisibilityMode, METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FVisibilitySettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInReducer,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseVisibilityWeightsInTexcoordGenerator,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_VisibilityWeightsPower,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CullOccludedGeometry,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ForceVisibilityCalculation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_UseBackfaceCulling,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_CameraSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_OccluderSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_FillNonVisibleAreaThreshold,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_RemoveTrianglesNotOccludingOtherTriangles,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ConservativeMode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVisibilitySettings_Statics::NewProp_ComputeVisibilityMode,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVisibilitySettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"VisibilitySettings",
		sizeof(FVisibilitySettings),
		alignof(FVisibilitySettings),
		Z_Construct_UScriptStruct_FVisibilitySettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVisibilitySettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVisibilitySettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVisibilitySettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VisibilitySettings"), sizeof(FVisibilitySettings), Get_Z_Construct_UScriptStruct_FVisibilitySettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVisibilitySettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVisibilitySettings_Hash() { return 2034222203U; }
class UScriptStruct* FNormalCalculationSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FNormalCalculationSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FNormalCalculationSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("NormalCalculationSettings"), sizeof(FNormalCalculationSettings), Get_Z_Construct_UScriptStruct_FNormalCalculationSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FNormalCalculationSettings>()
{
	return FNormalCalculationSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FNormalCalculationSettings(FNormalCalculationSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("NormalCalculationSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCalculationSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCalculationSettings()
	{
		UScriptStruct::DeferCppStructOps<FNormalCalculationSettings>(FName(TEXT("NormalCalculationSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFNormalCalculationSettings;
	struct Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReplaceNormals_MetaData[];
#endif
		static void NewProp_ReplaceNormals_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReplaceNormals;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReplaceTangents_MetaData[];
#endif
		static void NewProp_ReplaceTangents_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReplaceTangents;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HardEdgeAngle_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_HardEdgeAngle;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RepairInvalidNormals_MetaData[];
#endif
		static void NewProp_RepairInvalidNormals_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_RepairInvalidNormals;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReorthogonalizeTangentSpace_MetaData[];
#endif
		static void NewProp_ReorthogonalizeTangentSpace_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReorthogonalizeTangentSpace;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ScaleByArea_MetaData[];
#endif
		static void NewProp_ScaleByArea_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ScaleByArea;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ScaleByAngle_MetaData[];
#endif
		static void NewProp_ScaleByAngle_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ScaleByAngle;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SnapNormalsToFlatSurfaces_MetaData[];
#endif
		static void NewProp_SnapNormalsToFlatSurfaces_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_SnapNormalsToFlatSurfaces;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FNormalCalculationSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, it will generate new normals for the Geometry, and if not set, it will keep the normals from the original normal set (or not add normals at all if none were present). Please note that if the original geometry contains normals, the normal repairer will replace invalid normals even if ReplaceNormals is set to false. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, it will generate new normals for the Geometry, and if not set, it will keep the normals from the original normal set (or not add normals at all if none were present). Please note that if the original geometry contains normals, the normal repairer will replace invalid normals even if ReplaceNormals is set to false." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->ReplaceNormals = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals = { "ReplaceNormals", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, it will generate new tangents and bitangents for the Geometry, and if not set, it will keep the new tangents and bitangents from the original normal set (or not add tangents and bitangents at all if none were present). */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, it will generate new tangents and bitangents for the Geometry, and if not set, it will keep the new tangents and bitangents from the original normal set (or not add tangents and bitangents at all if none were present)." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->ReplaceTangents = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents = { "ReplaceTangents", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_HardEdgeAngle_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** Set HardEdgeAngle in degrees. If the angle between two triangles are above this value, the normals will not be smooth over the edge between those two triangles. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set HardEdgeAngle in degrees. If the angle between two triangles are above this value, the normals will not be smooth over the edge between those two triangles." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_HardEdgeAngle = { "HardEdgeAngle", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FNormalCalculationSettings, HardEdgeAngle), METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_HardEdgeAngle_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_HardEdgeAngle_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, normals that are invalid will be replaced. All others are left intact. Bad normals are those that are either zero length, or simply points away from the surface. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, normals that are invalid will be replaced. All others are left intact. Bad normals are those that are either zero length, or simply points away from the surface." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->RepairInvalidNormals = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals = { "RepairInvalidNormals", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, the tangentspaces already existing in the scene will be readjusted so that the tangent and binormal are both orthogonal to the normal. Will be needed since most of the time the normals are changed in the reduction process. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the tangentspaces already existing in the scene will be readjusted so that the tangent and binormal are both orthogonal to the normal. Will be needed since most of the time the normals are changed in the reduction process." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->ReorthogonalizeTangentSpace = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace = { "ReorthogonalizeTangentSpace", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, the influence of a triangle normal upon the vertex normals is scaled by the area of the triangle. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the influence of a triangle normal upon the vertex normals is scaled by the area of the triangle." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->ScaleByArea = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea = { "ScaleByArea", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, the influence of a triangle normal upon the vertex normals is scaled by the angle of the corner at the vertex. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, the influence of a triangle normal upon the vertex normals is scaled by the angle of the corner at the vertex." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->ScaleByAngle = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle = { "ScaleByAngle", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces_MetaData[] = {
		{ "Category", "NormalCalculationSettings" },
		{ "Comment", "/** If set, perfectly flat shaded surfaces will be created, where possible. Normals adjacent to perfectly geometrically flat surfaces will be recalculated to have the same direction as for those of the adjacent flat surface. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, perfectly flat shaded surfaces will be created, where possible. Normals adjacent to perfectly geometrically flat surfaces will be recalculated to have the same direction as for those of the adjacent flat surface." },
	};
#endif
	void Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces_SetBit(void* Obj)
	{
		((FNormalCalculationSettings*)Obj)->SnapNormalsToFlatSurfaces = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces = { "SnapNormalsToFlatSurfaces", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FNormalCalculationSettings), &Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceNormals,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReplaceTangents,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_HardEdgeAngle,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_RepairInvalidNormals,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ReorthogonalizeTangentSpace,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByArea,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_ScaleByAngle,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::NewProp_SnapNormalsToFlatSurfaces,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"NormalCalculationSettings",
		sizeof(FNormalCalculationSettings),
		alignof(FNormalCalculationSettings),
		Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FNormalCalculationSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FNormalCalculationSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("NormalCalculationSettings"), sizeof(FNormalCalculationSettings), Get_Z_Construct_UScriptStruct_FNormalCalculationSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FNormalCalculationSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FNormalCalculationSettings_Hash() { return 141062587U; }
class UScriptStruct* FRepairSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FRepairSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FRepairSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("RepairSettings"), sizeof(FRepairSettings), Get_Z_Construct_UScriptStruct_FRepairSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FRepairSettings>()
{
	return FRepairSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FRepairSettings(FRepairSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("RepairSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRepairSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFRepairSettings()
	{
		UScriptStruct::DeferCppStructOps<FRepairSettings>(FName(TEXT("RepairSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFRepairSettings;
	struct Z_Construct_UScriptStruct_FRepairSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseTJunctionRemover_MetaData[];
#endif
		static void NewProp_UseTJunctionRemover_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseTJunctionRemover;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TJuncDist_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_TJuncDist;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeldDist_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_WeldDist;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeldOnlyBorderVertices_MetaData[];
#endif
		static void NewProp_WeldOnlyBorderVertices_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_WeldOnlyBorderVertices;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeldOnlyWithinMaterial_MetaData[];
#endif
		static void NewProp_WeldOnlyWithinMaterial_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_WeldOnlyWithinMaterial;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeldOnlyWithinSceneNode_MetaData[];
#endif
		static void NewProp_WeldOnlyWithinSceneNode_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_WeldOnlyWithinSceneNode;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_WeldOnlyBetweenSceneNodes_MetaData[];
#endif
		static void NewProp_WeldOnlyBetweenSceneNodes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_WeldOnlyBetweenSceneNodes;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseWelding_MetaData[];
#endif
		static void NewProp_UseWelding_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseWelding;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProgressivePasses_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ProgressivePasses;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FRepairSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRepairSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, t-junctions will be removed. If enabled, it also requires UseWelding to be on. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, t-junctions will be removed. If enabled, it also requires UseWelding to be on." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->UseTJunctionRemover = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover = { "UseTJunctionRemover", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_TJuncDist_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** The T-Junction distance, below which, the T-Junctions will be welded. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The T-Junction distance, below which, the T-Junctions will be welded." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_TJuncDist = { "TJuncDist", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRepairSettings, TJuncDist), METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_TJuncDist_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_TJuncDist_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldDist_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** The welding distance below which the vertices will be welded. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The welding distance below which the vertices will be welded." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldDist = { "WeldDist", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRepairSettings, WeldDist), METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldDist_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldDist_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, only vertices that are on the border (as reported by the VertexBorder boolean field) are considered for the welding. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, only vertices that are on the border (as reported by the VertexBorder boolean field) are considered for the welding." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->WeldOnlyBorderVertices = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices = { "WeldOnlyBorderVertices", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, only vertices that are within the same material are welded. Vertices on material borders are locked. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, only vertices that are within the same material are welded. Vertices on material borders are locked." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->WeldOnlyWithinMaterial = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial = { "WeldOnlyWithinMaterial", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, only vertices that are within the same scene node are welded. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, only vertices that are within the same scene node are welded." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->WeldOnlyWithinSceneNode = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode = { "WeldOnlyWithinSceneNode", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, only vertices that belong to different scene nodes are considered for the welding. Affects both welder and t-junction remover. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, only vertices that belong to different scene nodes are considered for the welding. Affects both welder and t-junction remover." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->WeldOnlyBetweenSceneNodes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes = { "WeldOnlyBetweenSceneNodes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** If set, vertices within each others welding distance will be welded together. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, vertices within each others welding distance will be welded together." },
	};
#endif
	void Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding_SetBit(void* Obj)
	{
		((FRepairSettings*)Obj)->UseWelding = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding = { "UseWelding", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FRepairSettings), &Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_ProgressivePasses_MetaData[] = {
		{ "Category", "RepairSettings" },
		{ "Comment", "/** The number of progressive passes. Minimum is 1, but higher numbers give a better quality, at the expense of longer running time. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The number of progressive passes. Minimum is 1, but higher numbers give a better quality, at the expense of longer running time." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_ProgressivePasses = { "ProgressivePasses", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FRepairSettings, ProgressivePasses), METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_ProgressivePasses_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_ProgressivePasses_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRepairSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseTJunctionRemover,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_TJuncDist,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldDist,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBorderVertices,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinMaterial,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyWithinSceneNode,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_WeldOnlyBetweenSceneNodes,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_UseWelding,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRepairSettings_Statics::NewProp_ProgressivePasses,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRepairSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"RepairSettings",
		sizeof(FRepairSettings),
		alignof(FRepairSettings),
		Z_Construct_UScriptStruct_FRepairSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FRepairSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRepairSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FRepairSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FRepairSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("RepairSettings"), sizeof(FRepairSettings), Get_Z_Construct_UScriptStruct_FRepairSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FRepairSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FRepairSettings_Hash() { return 3257289682U; }
class UScriptStruct* FReductionSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FReductionSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FReductionSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("ReductionSettings"), sizeof(FReductionSettings), Get_Z_Construct_UScriptStruct_FReductionSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FReductionSettings>()
{
	return FReductionSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FReductionSettings(FReductionSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("ReductionSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionSettings()
	{
		UScriptStruct::DeferCppStructOps<FReductionSettings>(FName(TEXT("ReductionSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFReductionSettings;
	struct Z_Construct_UScriptStruct_FReductionSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetTriangleRatioEnabled_MetaData[];
#endif
		static void NewProp_ReductionTargetTriangleRatioEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReductionTargetTriangleRatioEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetTriangleRatio_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ReductionTargetTriangleRatio;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetTriangleCountEnabled_MetaData[];
#endif
		static void NewProp_ReductionTargetTriangleCountEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReductionTargetTriangleCountEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetTriangleCount_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ReductionTargetTriangleCount;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetMaxDeviationEnabled_MetaData[];
#endif
		static void NewProp_ReductionTargetMaxDeviationEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReductionTargetMaxDeviationEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetMaxDeviation_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ReductionTargetMaxDeviation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetOnScreenSizeEnabled_MetaData[];
#endif
		static void NewProp_ReductionTargetOnScreenSizeEnabled_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReductionTargetOnScreenSizeEnabled;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetOnScreenSize_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ReductionTargetOnScreenSize;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReductionTargetStopCondition_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionTargetStopCondition_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReductionTargetStopCondition;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReductionHeuristics_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReductionHeuristics_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReductionHeuristics;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GeometryImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaterialImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MaterialImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TextureImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_TextureImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ShadingImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ShadingImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GroupImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GroupImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VertexColorImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_VertexColorImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_EdgeSetImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_EdgeSetImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SkinningImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SkinningImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CurvatureImportance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_CurvatureImportance;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CreateGeomorphGeometry_MetaData[];
#endif
		static void NewProp_CreateGeomorphGeometry_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_CreateGeomorphGeometry;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_AllowDegenerateTexCoords_MetaData[];
#endif
		static void NewProp_AllowDegenerateTexCoords_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_AllowDegenerateTexCoords;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_KeepSymmetry_MetaData[];
#endif
		static void NewProp_KeepSymmetry_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_KeepSymmetry;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseAutomaticSymmetryDetection_MetaData[];
#endif
		static void NewProp_UseAutomaticSymmetryDetection_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseAutomaticSymmetryDetection;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseSymmetryQuadRetriangulator_MetaData[];
#endif
		static void NewProp_UseSymmetryQuadRetriangulator_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseSymmetryQuadRetriangulator;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_SymmetryAxis_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SymmetryAxis_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_SymmetryAxis;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SymmetryOffset_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SymmetryOffset;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SymmetryDetectionTolerance_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_SymmetryDetectionTolerance;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_DataCreationPreferences_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DataCreationPreferences_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DataCreationPreferences;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenerateGeomorphData_MetaData[];
#endif
		static void NewProp_GenerateGeomorphData_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_GenerateGeomorphData;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OutwardMoveMultiplier_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_OutwardMoveMultiplier;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_InwardMoveMultiplier_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_InwardMoveMultiplier;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MaxEdgeLength_MetaData[];
#endif
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MaxEdgeLength;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseHighQualityNormalCalculation_MetaData[];
#endif
		static void NewProp_UseHighQualityNormalCalculation_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseHighQualityNormalCalculation;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetID_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ProcessSelectionSetID;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProcessSelectionSetName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_ProcessSelectionSetName;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_MergeGeometries_MetaData[];
#endif
		static void NewProp_MergeGeometries_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_MergeGeometries;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_KeepUnprocessedSceneMeshes_MetaData[];
#endif
		static void NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_KeepUnprocessedSceneMeshes;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LockGeometricBorder_MetaData[];
#endif
		static void NewProp_LockGeometricBorder_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_LockGeometricBorder;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FReductionSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FReductionSettings>();
	}
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Enable triangle ratio as a reduction target. The reducer will stop when the set triangle-ratio has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable triangle ratio as a reduction target. The reducer will stop when the set triangle-ratio has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->ReductionTargetTriangleRatioEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled = { "ReductionTargetTriangleRatioEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatio_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The wanted reduction ratio. The range is 0->1. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The wanted reduction ratio. The range is 0->1." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatio = { "ReductionTargetTriangleRatio", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionTargetTriangleRatio), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatio_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatio_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Enable triangle count as a reduction target. The reducer will stop when the set triangle count has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable triangle count as a reduction target. The reducer will stop when the set triangle count has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->ReductionTargetTriangleCountEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled = { "ReductionTargetTriangleCountEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCount_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The wanted triangle count. The range is 0->inf. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The wanted triangle count. The range is 0->inf." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCount = { "ReductionTargetTriangleCount", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionTargetTriangleCount), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCount_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCount_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Enable max deviation as a reduction target. The reducer will stop when the set max deviation has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable max deviation as a reduction target. The reducer will stop when the set max deviation has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->ReductionTargetMaxDeviationEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled = { "ReductionTargetMaxDeviationEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviation_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The MaxDeviation value, the maximum surface-deviation between the reduced geometry and the original. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The MaxDeviation value, the maximum surface-deviation between the reduced geometry and the original." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviation = { "ReductionTargetMaxDeviation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionTargetMaxDeviation), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Enable on screen size as a reduction target. The reducer will stop when the set on screen size has been reached. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Enable on screen size as a reduction target. The reducer will stop when the set on screen size has been reached." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->ReductionTargetOnScreenSizeEnabled = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled = { "ReductionTargetOnScreenSizeEnabled", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSize_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The OnScreenSize value, used to calculate the maximum surface-deviation allowed, by assuming errors less than 1 pixel onscreen will not be noticeable. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The OnScreenSize value, used to calculate the maximum surface-deviation allowed, by assuming errors less than 1 pixel onscreen will not be noticeable." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSize = { "ReductionTargetOnScreenSize", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionTargetOnScreenSize), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSize_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSize_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The stop condition for the reducer.  Any -> the reducer will stop when any single one of the set reduction targets have been reached.  All -> the reducer will stop when all enabled reduction targets have been set. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The stop condition for the reducer.  Any -> the reducer will stop when any single one of the set reduction targets have been reached.  All -> the reducer will stop when all enabled reduction targets have been set." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition = { "ReductionTargetStopCondition", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionTargetStopCondition), Z_Construct_UEnum_SimplygonUObjects_EReductionTargetStopCondition, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The flag that decides how precise the reducer will be during the mesh reduction. Fast -> Reducer will be faster, but onscreensize and trianglecount will not match perfectly.  Consistent -> Reducer will be slower, but onscreensize and trianglecount will consistently give matching results. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The flag that decides how precise the reducer will be during the mesh reduction. Fast -> Reducer will be faster, but onscreensize and trianglecount will not match perfectly.  Consistent -> Reducer will be slower, but onscreensize and trianglecount will consistently give matching results." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics = { "ReductionHeuristics", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ReductionHeuristics), Z_Construct_UEnum_SimplygonUObjects_EReductionHeuristics, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GeometryImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the position of the vertices and triangles of the Geometry, or the silhouette of the Geometry. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the position of the vertices and triangles of the Geometry, or the silhouette of the Geometry. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GeometryImportance = { "GeometryImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, GeometryImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GeometryImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GeometryImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaterialImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the boundary between triangles with different materials. For example, if triangles with a metallic material are connected to triangles with a wood material, this setting will determine how important it is to keep the border between them intact. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the boundary between triangles with different materials. For example, if triangles with a metallic material are connected to triangles with a wood material, this setting will determine how important it is to keep the border between them intact. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaterialImportance = { "MaterialImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, MaterialImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaterialImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaterialImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_TextureImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the UV coordinates of the Geometry, both the boundary of the UV charts, as well as the UV stretch across the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the UV coordinates of the Geometry, both the boundary of the UV charts, as well as the UV stretch across the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_TextureImportance = { "TextureImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, TextureImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_TextureImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_TextureImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ShadingImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the vertex-normals of the Geometry, both the sharp edges, as well as how the normals interpolate over the surface of the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the vertex-normals of the Geometry, both the sharp edges, as well as how the normals interpolate over the surface of the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ShadingImportance = { "ShadingImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ShadingImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ShadingImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ShadingImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GroupImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the boundary between triangles from different sub-geometries. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the boundary between triangles from different sub-geometries. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GroupImportance = { "GroupImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, GroupImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GroupImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GroupImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_VertexColorImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the vertex-colors of the Geometry, both the boundary between triangles with different colors, as well as how the colors interpolate over the surface of the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the vertex-colors of the Geometry, both the boundary between triangles with different colors, as well as how the colors interpolate over the surface of the triangles. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_VertexColorImportance = { "VertexColorImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, VertexColorImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_VertexColorImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_VertexColorImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_EdgeSetImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of user selected edges. Can be used when a Boolean UserCornerField with the name SgEdgeSelectionSet is added to the Geometry. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of user selected edges. Can be used when a Boolean UserCornerField with the name SgEdgeSelectionSet is added to the Geometry. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_EdgeSetImportance = { "EdgeSetImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, EdgeSetImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_EdgeSetImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_EdgeSetImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SkinningImportance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The importance value of the bone-weights of the vertices. The more impact a vertex has on the skinning of the Geometry (for example, vertices close to joints), the more likely it is to be kept. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0 */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The importance value of the bone-weights of the vertices. The more impact a vertex has on the skinning of the Geometry (for example, vertices close to joints), the more likely it is to be kept. The importance is relative to the values of the other mesh features (or disabling an importance entirely by setting it to 0). A higher number means higher importance. Default is 1.0" },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SkinningImportance = { "SkinningImportance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, SkinningImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SkinningImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SkinningImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CurvatureImportance_MetaData[] = {
		{ "Comment", "/** This importance is deprecated and disabled. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "This importance is deprecated and disabled." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CurvatureImportance = { "CurvatureImportance", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, CurvatureImportance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CurvatureImportance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CurvatureImportance_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The CreateGeomorphGeometry value. If set, the reducer will create a GeometryData object that is a morphed version of the original GeometryData, that can be used to morph between the original geometry and the reduced geometry. Should not be used together with TJunctionRemover, NormalRecalculation or Material LOD. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The CreateGeomorphGeometry value. If set, the reducer will create a GeometryData object that is a morphed version of the original GeometryData, that can be used to morph between the original geometry and the reduced geometry. Should not be used together with TJunctionRemover, NormalRecalculation or Material LOD." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->CreateGeomorphGeometry = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry = { "CreateGeomorphGeometry", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The AllowDegenerateTexCoords flag. If true, texture coordinates are allowed to become degenerate (triangles can have 0 area in texture space). This may sometimes look better, but if tangent space normals are used, tangent spaces may become degenerate. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The AllowDegenerateTexCoords flag. If true, texture coordinates are allowed to become degenerate (triangles can have 0 area in texture space). This may sometimes look better, but if tangent space normals are used, tangent spaces may become degenerate." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->AllowDegenerateTexCoords = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords = { "AllowDegenerateTexCoords", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The KeepSymmetry flag. If set, the reducer will detect symmetric features, and retain symmetry during processing. Please note that for a geometry to be considered symmetrical, also the texture coordinates must be mirrored. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The KeepSymmetry flag. If set, the reducer will detect symmetric features, and retain symmetry during processing. Please note that for a geometry to be considered symmetrical, also the texture coordinates must be mirrored." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->KeepSymmetry = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry = { "KeepSymmetry", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The AutomaticSymmetryDetection flag. If set, and KeepSymmetry is on, the reducer will detect any X,Y,Z symmetry plane and will override any user set symmetry plane with the detected one. If no symmetry is found, KeepSymmetry will be turned off before reduction. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The AutomaticSymmetryDetection flag. If set, and KeepSymmetry is on, the reducer will detect any X,Y,Z symmetry plane and will override any user set symmetry plane with the detected one. If no symmetry is found, KeepSymmetry will be turned off before reduction." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->UseAutomaticSymmetryDetection = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection = { "UseAutomaticSymmetryDetection", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The UseSymmetryQuadRetriangulator flag. If true, and KeepSymmetry is on, any triangles that have been triangulated from symmetrical quads into unsymmetrical triangles are detected and fixed. The edges of said triangles are flipped across the old quad so that the mesh becomes symmetrical again. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The UseSymmetryQuadRetriangulator flag. If true, and KeepSymmetry is on, any triangles that have been triangulated from symmetrical quads into unsymmetrical triangles are detected and fixed. The edges of said triangles are flipped across the old quad so that the mesh becomes symmetrical again." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->UseSymmetryQuadRetriangulator = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator = { "UseSymmetryQuadRetriangulator", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Set what axis to be used for symmetry calculations. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set what axis to be used for symmetry calculations." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis = { "SymmetryAxis", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, SymmetryAxis), Z_Construct_UEnum_SimplygonUObjects_ESymmetryAxis, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryOffset_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Set SymmetryOffset, the position on the symmetry axis where the symmetry plane is placed. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set SymmetryOffset, the position on the symmetry axis where the symmetry plane is placed." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryOffset = { "SymmetryOffset", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, SymmetryOffset), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryOffset_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryOffset_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryDetectionTolerance_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The tolerance used when detecting symmetry. Values in the ranges 1e-5 to 1e-3 will usually produce good results. This specific tolerance corresponds to the off-plane tolerance, ie. the tolerance of the coordinate components that are not the symmetry axis. The in-plane tolerance is always 10 times the off-plane tolerance. This value is relative to the size of the Geometry, so 0.01 would mean 1% of the bounding box size of the Geometry. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The tolerance used when detecting symmetry. Values in the ranges 1e-5 to 1e-3 will usually produce good results. This specific tolerance corresponds to the off-plane tolerance, ie. the tolerance of the coordinate components that are not the symmetry axis. The in-plane tolerance is always 10 times the off-plane tolerance. This value is relative to the size of the Geometry, so 0.01 would mean 1% of the bounding box size of the Geometry." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryDetectionTolerance = { "SymmetryDetectionTolerance", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, SymmetryDetectionTolerance), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryDetectionTolerance_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryDetectionTolerance_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The flag that specifies how big 'freedom' Simplygon has when it comes to altering vertex/triangle data. Allowing more altered data means it will be easier to create good looking LODs, but without altered data it will be easier to keep the memory-usage in the LOD-chain more optimized. Note: When using OnlyUseOriginalData, the geometry being reduced can not have a node transformation matrix other than the identity matrix. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The flag that specifies how big 'freedom' Simplygon has when it comes to altering vertex/triangle data. Allowing more altered data means it will be easier to create good looking LODs, but without altered data it will be easier to keep the memory-usage in the LOD-chain more optimized. Note: When using OnlyUseOriginalData, the geometry being reduced can not have a node transformation matrix other than the identity matrix." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences = { "DataCreationPreferences", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, DataCreationPreferences), Z_Construct_UEnum_SimplygonUObjects_EDataCreationPreferences, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The flag for if the reduction process should store geomorph data in the processed GeometryData object. This data is an array with same size as the vertexcount was before the reduction process, and will have the coordinates for each vertex on its corresponding position on the reduced GeometryData surface. Can be used to give smooth transition from a highlevel LOD to a lowlevel LOD. This array can be accessed with the GeometryData custom field 'SgMappedVertexCoords'. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The flag for if the reduction process should store geomorph data in the processed GeometryData object. This data is an array with same size as the vertexcount was before the reduction process, and will have the coordinates for each vertex on its corresponding position on the reduced GeometryData surface. Can be used to give smooth transition from a highlevel LOD to a lowlevel LOD. This array can be accessed with the GeometryData custom field 'SgMappedVertexCoords'." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->GenerateGeomorphData = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData = { "GenerateGeomorphData", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_OutwardMoveMultiplier_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The outward move multiplier, how much the mesh is allowed to grow its silhouette perimeter. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The outward move multiplier, how much the mesh is allowed to grow its silhouette perimeter." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_OutwardMoveMultiplier = { "OutwardMoveMultiplier", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, OutwardMoveMultiplier), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_OutwardMoveMultiplier_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_OutwardMoveMultiplier_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_InwardMoveMultiplier_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The inward move multiplier, how much the mesh is allowed to shrink its silhouette perimeter. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The inward move multiplier, how much the mesh is allowed to shrink its silhouette perimeter." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_InwardMoveMultiplier = { "InwardMoveMultiplier", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, InwardMoveMultiplier), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_InwardMoveMultiplier_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_InwardMoveMultiplier_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaxEdgeLength_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The maximum length of the triangles edges after reduction. Can be used to limit output triangle size. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The maximum length of the triangles edges after reduction. Can be used to limit output triangle size." },
	};
#endif
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaxEdgeLength = { "MaxEdgeLength", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, MaxEdgeLength), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaxEdgeLength_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaxEdgeLength_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** Set to true and the reducer will do a much more precise way of calculating the vertex normals. It will however be slower. Set to false and it will do a much more rough estimation of what the vertex normals will look like, but faster. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Set to true and the reducer will do a much more precise way of calculating the vertex normals. It will however be slower. Set to false and it will do a much more rough estimation of what the vertex normals will look like, but faster." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->UseHighQualityNormalCalculation = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation = { "UseHighQualityNormalCalculation", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetID_MetaData[] = {
		{ "Comment", "/** Which selection set should be processed. If set to -1, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which selection set should be processed. If set to -1, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetID = { "ProcessSelectionSetID", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ProcessSelectionSetID), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetID_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetID_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetName_MetaData[] = {
		{ "Comment", "/** Which selection set should be processed. If the name is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "Which selection set should be processed. If the name is not found, all geometries in the scene will be processed. If both selection set name and ID are set, the name will be used." },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetName = { "ProcessSelectionSetName", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FReductionSettings, ProcessSelectionSetName), METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetName_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** The processor will merge all the geometries in the scene into a single geometry if MergeGeometries is enabled. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "The processor will merge all the geometries in the scene into a single geometry if MergeGeometries is enabled." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->MergeGeometries = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries = { "MergeGeometries", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** If false, the processor will remove all geometry and scene meshes which were not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated, while the rest of the scene tree is kept intact. New geometry is always added as the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones. */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If false, the processor will remove all geometry and scene meshes which were not selected for processing from the scene. If true, only the geometry in the ProcessSelectionSet will be replaced or updated, while the rest of the scene tree is kept intact. New geometry is always added as the last child of the scene root. If generating a mappingimage to cast materials, new materialIds will also be appended to the end of the old material table instead of replacing the old ones." },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->KeepUnprocessedSceneMeshes = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes = { "KeepUnprocessedSceneMeshes", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder_MetaData[] = {
		{ "Category", "ReductionSettings" },
		{ "Comment", "/** If set, will lock the geometric border of the geometry, and not reduce at all. This setting might be useful if the geometry needs to fit a neighbor geometry, but will reduce overall reduction quality (geometric quality over reduction ratio) */" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
		{ "ToolTip", "If set, will lock the geometric border of the geometry, and not reduce at all. This setting might be useful if the geometry needs to fit a neighbor geometry, but will reduce overall reduction quality (geometric quality over reduction ratio)" },
	};
#endif
	void Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder_SetBit(void* Obj)
	{
		((FReductionSettings*)Obj)->LockGeometricBorder = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder = { "LockGeometricBorder", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(uint8), sizeof(FReductionSettings), &Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder_SetBit, METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FReductionSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatioEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleRatio,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCountEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetTriangleCount,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviationEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetMaxDeviation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSizeEnabled,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetOnScreenSize,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionTargetStopCondition,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ReductionHeuristics,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GeometryImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaterialImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_TextureImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ShadingImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GroupImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_VertexColorImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_EdgeSetImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SkinningImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CurvatureImportance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_CreateGeomorphGeometry,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_AllowDegenerateTexCoords,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepSymmetry,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseAutomaticSymmetryDetection,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseSymmetryQuadRetriangulator,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryAxis,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryOffset,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_SymmetryDetectionTolerance,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_DataCreationPreferences,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_GenerateGeomorphData,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_OutwardMoveMultiplier,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_InwardMoveMultiplier,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MaxEdgeLength,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_UseHighQualityNormalCalculation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetID,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_ProcessSelectionSetName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_MergeGeometries,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_KeepUnprocessedSceneMeshes,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FReductionSettings_Statics::NewProp_LockGeometricBorder,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FReductionSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"ReductionSettings",
		sizeof(FReductionSettings),
		alignof(FReductionSettings),
		Z_Construct_UScriptStruct_FReductionSettings_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FReductionSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FReductionSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FReductionSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FReductionSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("ReductionSettings"), sizeof(FReductionSettings), Get_Z_Construct_UScriptStruct_FReductionSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FReductionSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FReductionSettings_Hash() { return 3659915910U; }
class UScriptStruct* FSimplygonPipelineSettings::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern SIMPLYGONUOBJECTS_API uint32 Get_Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FSimplygonPipelineSettings, Z_Construct_UPackage__Script_SimplygonUObjects(), TEXT("SimplygonPipelineSettings"), sizeof(FSimplygonPipelineSettings), Get_Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Hash());
	}
	return Singleton;
}
template<> SIMPLYGONUOBJECTS_API UScriptStruct* StaticStruct<FSimplygonPipelineSettings>()
{
	return FSimplygonPipelineSettings::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FSimplygonPipelineSettings(FSimplygonPipelineSettings::StaticStruct, TEXT("/Script/SimplygonUObjects"), TEXT("SimplygonPipelineSettings"), false, nullptr, nullptr);
static struct FScriptStruct_SimplygonUObjects_StaticRegisterNativesFSimplygonPipelineSettings
{
	FScriptStruct_SimplygonUObjects_StaticRegisterNativesFSimplygonPipelineSettings()
	{
		UScriptStruct::DeferCppStructOps<FSimplygonPipelineSettings>(FName(TEXT("SimplygonPipelineSettings")));
	}
} ScriptStruct_SimplygonUObjects_StaticRegisterNativesFSimplygonPipelineSettings;
	struct Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::Struct_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FSimplygonPipelineSettings>();
	}
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
		nullptr,
		&NewStructOps,
		"SimplygonPipelineSettings",
		sizeof(FSimplygonPipelineSettings),
		alignof(FSimplygonPipelineSettings),
		nullptr,
		0,
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000201),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FSimplygonPipelineSettings()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonUObjects();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("SimplygonPipelineSettings"), sizeof(FSimplygonPipelineSettings), Get_Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FSimplygonPipelineSettings_Hash() { return 539754466U; }
	void USimplygonPipeline::StaticRegisterNativesUSimplygonPipeline()
	{
	}
	UClass* Z_Construct_UClass_USimplygonPipeline_NoRegister()
	{
		return USimplygonPipeline::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonPipeline_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonPipeline_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UObject,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonPipeline_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonPipeline_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonPipeline>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonPipeline_Statics::ClassParams = {
		&USimplygonPipeline::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		nullptr,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		0,
		0,
		0x003010A1u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonPipeline_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonPipeline_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonPipeline()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonPipeline_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonPipeline, 1246588654);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonPipeline>()
	{
		return USimplygonPipeline::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonPipeline(Z_Construct_UClass_USimplygonPipeline, &USimplygonPipeline::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonPipeline"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonPipeline);
	void USimplygonMaterialCaster::StaticRegisterNativesUSimplygonMaterialCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonMaterialCaster_NoRegister()
	{
		return USimplygonMaterialCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonMaterialCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonMaterialCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UObject,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonMaterialCaster_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonMaterialCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonMaterialCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonMaterialCaster_Statics::ClassParams = {
		&USimplygonMaterialCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		nullptr,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		0,
		0,
		0x003010A1u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonMaterialCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonMaterialCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonMaterialCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonMaterialCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonMaterialCaster, 4173788169);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonMaterialCaster>()
	{
		return USimplygonMaterialCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonMaterialCaster(Z_Construct_UClass_USimplygonMaterialCaster, &USimplygonMaterialCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonMaterialCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonMaterialCaster);
	void UReductionPipeline::StaticRegisterNativesUReductionPipeline()
	{
	}
	UClass* Z_Construct_UClass_UReductionPipeline_NoRegister()
	{
		return UReductionPipeline::StaticClass();
	}
	struct Z_Construct_UClass_UReductionPipeline_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Settings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Settings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UReductionPipeline_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonPipeline,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UReductionPipeline_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UReductionPipeline_Statics::NewProp_Settings_MetaData[] = {
		{ "Category", "Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_UReductionPipeline_Statics::NewProp_Settings = { "Settings", nullptr, (EPropertyFlags)0x0010008000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UReductionPipeline, Settings), Z_Construct_UScriptStruct_FReductionPipelineSettings, METADATA_PARAMS(Z_Construct_UClass_UReductionPipeline_Statics::NewProp_Settings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UReductionPipeline_Statics::NewProp_Settings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UReductionPipeline_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UReductionPipeline_Statics::NewProp_Settings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UReductionPipeline_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UReductionPipeline>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UReductionPipeline_Statics::ClassParams = {
		&UReductionPipeline::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UReductionPipeline_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UReductionPipeline_Statics::PropPointers),
		0,
		0x00B010A0u,
		METADATA_PARAMS(Z_Construct_UClass_UReductionPipeline_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UReductionPipeline_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UReductionPipeline()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UReductionPipeline_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UReductionPipeline, 332630565);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<UReductionPipeline>()
	{
		return UReductionPipeline::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UReductionPipeline(Z_Construct_UClass_UReductionPipeline, &UReductionPipeline::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("UReductionPipeline"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UReductionPipeline);
	void URemeshingPipeline::StaticRegisterNativesURemeshingPipeline()
	{
	}
	UClass* Z_Construct_UClass_URemeshingPipeline_NoRegister()
	{
		return URemeshingPipeline::StaticClass();
	}
	struct Z_Construct_UClass_URemeshingPipeline_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Settings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Settings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_URemeshingPipeline_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonPipeline,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_URemeshingPipeline_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_URemeshingPipeline_Statics::NewProp_Settings_MetaData[] = {
		{ "Category", "Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_URemeshingPipeline_Statics::NewProp_Settings = { "Settings", nullptr, (EPropertyFlags)0x0010008000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(URemeshingPipeline, Settings), Z_Construct_UScriptStruct_FRemeshingPipelineSettings, METADATA_PARAMS(Z_Construct_UClass_URemeshingPipeline_Statics::NewProp_Settings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_URemeshingPipeline_Statics::NewProp_Settings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_URemeshingPipeline_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_URemeshingPipeline_Statics::NewProp_Settings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_URemeshingPipeline_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<URemeshingPipeline>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_URemeshingPipeline_Statics::ClassParams = {
		&URemeshingPipeline::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_URemeshingPipeline_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_URemeshingPipeline_Statics::PropPointers),
		0,
		0x00B010A0u,
		METADATA_PARAMS(Z_Construct_UClass_URemeshingPipeline_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_URemeshingPipeline_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_URemeshingPipeline()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_URemeshingPipeline_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(URemeshingPipeline, 774906511);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<URemeshingPipeline>()
	{
		return URemeshingPipeline::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_URemeshingPipeline(Z_Construct_UClass_URemeshingPipeline, &URemeshingPipeline::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("URemeshingPipeline"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(URemeshingPipeline);
	void UAggregationPipeline::StaticRegisterNativesUAggregationPipeline()
	{
	}
	UClass* Z_Construct_UClass_UAggregationPipeline_NoRegister()
	{
		return UAggregationPipeline::StaticClass();
	}
	struct Z_Construct_UClass_UAggregationPipeline_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Settings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Settings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UAggregationPipeline_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonPipeline,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAggregationPipeline_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAggregationPipeline_Statics::NewProp_Settings_MetaData[] = {
		{ "Category", "Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAggregationPipeline_Statics::NewProp_Settings = { "Settings", nullptr, (EPropertyFlags)0x0010008000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UAggregationPipeline, Settings), Z_Construct_UScriptStruct_FAggregationPipelineSettings, METADATA_PARAMS(Z_Construct_UClass_UAggregationPipeline_Statics::NewProp_Settings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UAggregationPipeline_Statics::NewProp_Settings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UAggregationPipeline_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAggregationPipeline_Statics::NewProp_Settings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UAggregationPipeline_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UAggregationPipeline>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UAggregationPipeline_Statics::ClassParams = {
		&UAggregationPipeline::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UAggregationPipeline_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UAggregationPipeline_Statics::PropPointers),
		0,
		0x00B010A0u,
		METADATA_PARAMS(Z_Construct_UClass_UAggregationPipeline_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UAggregationPipeline_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UAggregationPipeline()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UAggregationPipeline_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UAggregationPipeline, 4003384818);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<UAggregationPipeline>()
	{
		return UAggregationPipeline::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UAggregationPipeline(Z_Construct_UClass_UAggregationPipeline, &UAggregationPipeline::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("UAggregationPipeline"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UAggregationPipeline);
	void USimplygonColorCaster::StaticRegisterNativesUSimplygonColorCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonColorCaster_NoRegister()
	{
		return USimplygonColorCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonColorCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ColorCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_ColorCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonColorCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonColorCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonColorCaster_Statics::NewProp_ColorCasterSettings_MetaData[] = {
		{ "Category", "Color Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonColorCaster_Statics::NewProp_ColorCasterSettings = { "ColorCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonColorCaster, ColorCasterSettings), Z_Construct_UScriptStruct_FColorCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonColorCaster_Statics::NewProp_ColorCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonColorCaster_Statics::NewProp_ColorCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonColorCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonColorCaster_Statics::NewProp_ColorCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonColorCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonColorCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonColorCaster_Statics::ClassParams = {
		&USimplygonColorCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonColorCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonColorCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonColorCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonColorCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonColorCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonColorCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonColorCaster, 741620111);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonColorCaster>()
	{
		return USimplygonColorCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonColorCaster(Z_Construct_UClass_USimplygonColorCaster, &USimplygonColorCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonColorCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonColorCaster);
	void USimplygonOpacityCaster::StaticRegisterNativesUSimplygonOpacityCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonOpacityCaster_NoRegister()
	{
		return USimplygonOpacityCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonOpacityCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_OpacityCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_OpacityCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonOpacityCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonOpacityCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonOpacityCaster_Statics::NewProp_OpacityCasterSettings_MetaData[] = {
		{ "Category", "Opacity Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonOpacityCaster_Statics::NewProp_OpacityCasterSettings = { "OpacityCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonOpacityCaster, OpacityCasterSettings), Z_Construct_UScriptStruct_FOpacityCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonOpacityCaster_Statics::NewProp_OpacityCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonOpacityCaster_Statics::NewProp_OpacityCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonOpacityCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonOpacityCaster_Statics::NewProp_OpacityCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonOpacityCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonOpacityCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonOpacityCaster_Statics::ClassParams = {
		&USimplygonOpacityCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonOpacityCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonOpacityCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonOpacityCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonOpacityCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonOpacityCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonOpacityCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonOpacityCaster, 2108979651);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonOpacityCaster>()
	{
		return USimplygonOpacityCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonOpacityCaster(Z_Construct_UClass_USimplygonOpacityCaster, &USimplygonOpacityCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonOpacityCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonOpacityCaster);
	void USimplygonNormalCaster::StaticRegisterNativesUSimplygonNormalCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonNormalCaster_NoRegister()
	{
		return USimplygonNormalCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonNormalCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NormalCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_NormalCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonNormalCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonNormalCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonNormalCaster_Statics::NewProp_NormalCasterSettings_MetaData[] = {
		{ "Category", "Normal Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonNormalCaster_Statics::NewProp_NormalCasterSettings = { "NormalCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonNormalCaster, NormalCasterSettings), Z_Construct_UScriptStruct_FNormalCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonNormalCaster_Statics::NewProp_NormalCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonNormalCaster_Statics::NewProp_NormalCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonNormalCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonNormalCaster_Statics::NewProp_NormalCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonNormalCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonNormalCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonNormalCaster_Statics::ClassParams = {
		&USimplygonNormalCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonNormalCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonNormalCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonNormalCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonNormalCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonNormalCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonNormalCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonNormalCaster, 3567421086);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonNormalCaster>()
	{
		return USimplygonNormalCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonNormalCaster(Z_Construct_UClass_USimplygonNormalCaster, &USimplygonNormalCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonNormalCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonNormalCaster);
	void USimplygonDisplacementCaster::StaticRegisterNativesUSimplygonDisplacementCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonDisplacementCaster_NoRegister()
	{
		return USimplygonDisplacementCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonDisplacementCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DisplacementCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_DisplacementCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonDisplacementCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonDisplacementCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonDisplacementCaster_Statics::NewProp_DisplacementCasterSettings_MetaData[] = {
		{ "Category", "Displacement Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonDisplacementCaster_Statics::NewProp_DisplacementCasterSettings = { "DisplacementCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonDisplacementCaster, DisplacementCasterSettings), Z_Construct_UScriptStruct_FDisplacementCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonDisplacementCaster_Statics::NewProp_DisplacementCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonDisplacementCaster_Statics::NewProp_DisplacementCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonDisplacementCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonDisplacementCaster_Statics::NewProp_DisplacementCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonDisplacementCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonDisplacementCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonDisplacementCaster_Statics::ClassParams = {
		&USimplygonDisplacementCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonDisplacementCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonDisplacementCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonDisplacementCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonDisplacementCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonDisplacementCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonDisplacementCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonDisplacementCaster, 1955010809);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonDisplacementCaster>()
	{
		return USimplygonDisplacementCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonDisplacementCaster(Z_Construct_UClass_USimplygonDisplacementCaster, &USimplygonDisplacementCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonDisplacementCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonDisplacementCaster);
	void USimplygonAmbientOcclusionCaster::StaticRegisterNativesUSimplygonAmbientOcclusionCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonAmbientOcclusionCaster_NoRegister()
	{
		return USimplygonAmbientOcclusionCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_AmbientOcclusionCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_AmbientOcclusionCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::NewProp_AmbientOcclusionCasterSettings_MetaData[] = {
		{ "Category", "Ambient Occlusion Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::NewProp_AmbientOcclusionCasterSettings = { "AmbientOcclusionCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonAmbientOcclusionCaster, AmbientOcclusionCasterSettings), Z_Construct_UScriptStruct_FAmbientOcclusionCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::NewProp_AmbientOcclusionCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::NewProp_AmbientOcclusionCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::NewProp_AmbientOcclusionCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonAmbientOcclusionCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::ClassParams = {
		&USimplygonAmbientOcclusionCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonAmbientOcclusionCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonAmbientOcclusionCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonAmbientOcclusionCaster, 2243874392);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonAmbientOcclusionCaster>()
	{
		return USimplygonAmbientOcclusionCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonAmbientOcclusionCaster(Z_Construct_UClass_USimplygonAmbientOcclusionCaster, &USimplygonAmbientOcclusionCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonAmbientOcclusionCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonAmbientOcclusionCaster);
	void USimplygonGeometryDataCaster::StaticRegisterNativesUSimplygonGeometryDataCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonGeometryDataCaster_NoRegister()
	{
		return USimplygonGeometryDataCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonGeometryDataCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GeometryDataCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_GeometryDataCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::NewProp_GeometryDataCasterSettings_MetaData[] = {
		{ "Category", "Geometry Data Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::NewProp_GeometryDataCasterSettings = { "GeometryDataCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonGeometryDataCaster, GeometryDataCasterSettings), Z_Construct_UScriptStruct_FGeometryDataCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::NewProp_GeometryDataCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::NewProp_GeometryDataCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::NewProp_GeometryDataCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonGeometryDataCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::ClassParams = {
		&USimplygonGeometryDataCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonGeometryDataCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonGeometryDataCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonGeometryDataCaster, 1799364219);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonGeometryDataCaster>()
	{
		return USimplygonGeometryDataCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonGeometryDataCaster(Z_Construct_UClass_USimplygonGeometryDataCaster, &USimplygonGeometryDataCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonGeometryDataCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonGeometryDataCaster);
	void USimplygonVertexColorCaster::StaticRegisterNativesUSimplygonVertexColorCaster()
	{
	}
	UClass* Z_Construct_UClass_USimplygonVertexColorCaster_NoRegister()
	{
		return USimplygonVertexColorCaster::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonVertexColorCaster_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VertexColorCasterSettings_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_VertexColorCasterSettings;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonVertexColorCaster_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_USimplygonMaterialCaster,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonUObjects,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonVertexColorCaster_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "IncludePath", "SimplygonUE4UI.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonVertexColorCaster_Statics::NewProp_VertexColorCasterSettings_MetaData[] = {
		{ "Category", "Vertex Color Caster Settings" },
		{ "ModuleRelativePath", "Public/SimplygonUE4UI.h" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonVertexColorCaster_Statics::NewProp_VertexColorCasterSettings = { "VertexColorCasterSettings", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonVertexColorCaster, VertexColorCasterSettings), Z_Construct_UScriptStruct_FVertexColorCasterSettings, METADATA_PARAMS(Z_Construct_UClass_USimplygonVertexColorCaster_Statics::NewProp_VertexColorCasterSettings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonVertexColorCaster_Statics::NewProp_VertexColorCasterSettings_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonVertexColorCaster_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonVertexColorCaster_Statics::NewProp_VertexColorCasterSettings,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonVertexColorCaster_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonVertexColorCaster>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonVertexColorCaster_Statics::ClassParams = {
		&USimplygonVertexColorCaster::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonVertexColorCaster_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonVertexColorCaster_Statics::PropPointers),
		0,
		0x003010A0u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonVertexColorCaster_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonVertexColorCaster_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonVertexColorCaster()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonVertexColorCaster_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonVertexColorCaster, 794908869);
	template<> SIMPLYGONUOBJECTS_API UClass* StaticClass<USimplygonVertexColorCaster>()
	{
		return USimplygonVertexColorCaster::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonVertexColorCaster(Z_Construct_UClass_USimplygonVertexColorCaster, &USimplygonVertexColorCaster::StaticClass, TEXT("/Script/SimplygonUObjects"), TEXT("USimplygonVertexColorCaster"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonVertexColorCaster);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
