nlansing/DedicatedServerCourse
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ecb33115bfa7c25a378ce3c8c8eef39df1d887ab
DedicatedServerCourse/Intermediate/Build/Win64/FPSTemplateEditor/Inc/Engine/UHT/SoundConcurrency.gen.cpp

589 lines
45 KiB
C++
Raw Normal View History

Initial Commit
2026-01-28 19:08:51 -05:00
// 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 "Sound/SoundConcurrency.h"
#include "UObject/PerPlatformProperties.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
static_assert(!UE_WITH_CONSTINIT_UOBJECT, "This generated code can only be compiled with !UE_WITH_CONSTINIT_OBJECT");
void EmptyLinkFunctionForGeneratedCodeSoundConcurrency() {}
// ********** Begin Cross Module References ********************************************************
COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FPerPlatformInt();
ENGINE_API UClass* Z_Construct_UClass_USoundConcurrency();
ENGINE_API UClass* Z_Construct_UClass_USoundConcurrency_NoRegister();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FSoundConcurrencySettings();
UPackage* Z_Construct_UPackage__Script_Engine();
// ********** End Cross Module References **********************************************************
// ********** Begin Enum EMaxConcurrentResolutionRule **********************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule;
static UEnum* EMaxConcurrentResolutionRule_StaticEnum()
{
if (!Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.OuterSingleton)
{
Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("EMaxConcurrentResolutionRule"));
}
return Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.OuterSingleton;
}
template<> ENGINE_NON_ATTRIBUTED_API UEnum* StaticEnum<EMaxConcurrentResolutionRule::Type>()
{
return EMaxConcurrentResolutionRule_StaticEnum();
}
struct Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics
{
#if WITH_METADATA
static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "Count.Hidden", "" },
{ "Count.Name", "EMaxConcurrentResolutionRule::Count" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "PreventNew.Comment", "/** When Max Concurrent sounds are active do not start a new sound. */" },
{ "PreventNew.Name", "EMaxConcurrentResolutionRule::PreventNew" },
{ "PreventNew.ToolTip", "When Max Concurrent sounds are active do not start a new sound." },
{ "StopFarthestThenOldest.Comment", "/** When Max Concurrent sounds are active stop the furthest sound. If all sounds are the same distance then stop the oldest. */" },
{ "StopFarthestThenOldest.Name", "EMaxConcurrentResolutionRule::StopFarthestThenOldest" },
{ "StopFarthestThenOldest.ToolTip", "When Max Concurrent sounds are active stop the furthest sound. If all sounds are the same distance then stop the oldest." },
{ "StopFarthestThenPreventNew.Comment", "/** When Max Concurrent sounds are active stop the furthest sound. If all sounds are the same distance then do not start a new sound. */" },
{ "StopFarthestThenPreventNew.Name", "EMaxConcurrentResolutionRule::StopFarthestThenPreventNew" },
{ "StopFarthestThenPreventNew.ToolTip", "When Max Concurrent sounds are active stop the furthest sound. If all sounds are the same distance then do not start a new sound." },
{ "StopLowestPriority.Comment", "/** Stop the lowest priority sound in the group. If all sounds are the same priority, then it will stop the oldest sound in the group. */" },
{ "StopLowestPriority.Name", "EMaxConcurrentResolutionRule::StopLowestPriority" },
{ "StopLowestPriority.ToolTip", "Stop the lowest priority sound in the group. If all sounds are the same priority, then it will stop the oldest sound in the group." },
{ "StopLowestPriorityThenPreventNew.Comment", "/** Stop the lowest priority sound in the group. If all sounds are the same priority, then it won't play a new sound. */" },
{ "StopLowestPriorityThenPreventNew.Name", "EMaxConcurrentResolutionRule::StopLowestPriorityThenPreventNew" },
{ "StopLowestPriorityThenPreventNew.ToolTip", "Stop the lowest priority sound in the group. If all sounds are the same priority, then it won't play a new sound." },
{ "StopOldest.Comment", "/** When Max Concurrent sounds are active stop the oldest and start a new one. */" },
{ "StopOldest.Name", "EMaxConcurrentResolutionRule::StopOldest" },
{ "StopOldest.ToolTip", "When Max Concurrent sounds are active stop the oldest and start a new one." },
{ "StopQuietest.Comment", "/** Stop the sound that is quietest in the group. */" },
{ "StopQuietest.Name", "EMaxConcurrentResolutionRule::StopQuietest" },
{ "StopQuietest.ToolTip", "Stop the sound that is quietest in the group." },
};
#endif // WITH_METADATA
static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EMaxConcurrentResolutionRule::PreventNew", (int64)EMaxConcurrentResolutionRule::PreventNew },
{ "EMaxConcurrentResolutionRule::StopOldest", (int64)EMaxConcurrentResolutionRule::StopOldest },
{ "EMaxConcurrentResolutionRule::StopFarthestThenPreventNew", (int64)EMaxConcurrentResolutionRule::StopFarthestThenPreventNew },
{ "EMaxConcurrentResolutionRule::StopFarthestThenOldest", (int64)EMaxConcurrentResolutionRule::StopFarthestThenOldest },
{ "EMaxConcurrentResolutionRule::StopLowestPriority", (int64)EMaxConcurrentResolutionRule::StopLowestPriority },
{ "EMaxConcurrentResolutionRule::StopQuietest", (int64)EMaxConcurrentResolutionRule::StopQuietest },
{ "EMaxConcurrentResolutionRule::StopLowestPriorityThenPreventNew", (int64)EMaxConcurrentResolutionRule::StopLowestPriorityThenPreventNew },
{ "EMaxConcurrentResolutionRule::Count", (int64)EMaxConcurrentResolutionRule::Count },
};
static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_Engine,
nullptr,
"EMaxConcurrentResolutionRule",
"EMaxConcurrentResolutionRule::Type",
Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::Enumerators,
RF_Public|RF_Transient|RF_MarkAsNative,
UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::Enumerators),
EEnumFlags::None,
(uint8)UEnum::ECppForm::Namespaced,
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule()
{
if (!Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.InnerSingleton)
{
UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.InnerSingleton, Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule_Statics::EnumParams);
}
return Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule.InnerSingleton;
}
// ********** End Enum EMaxConcurrentResolutionRule ************************************************
// ********** Begin Enum EConcurrencyVolumeScaleMode ***********************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode;
static UEnum* EConcurrencyVolumeScaleMode_StaticEnum()
{
if (!Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.OuterSingleton)
{
Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("EConcurrencyVolumeScaleMode"));
}
return Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.OuterSingleton;
}
template<> ENGINE_NON_ATTRIBUTED_API UEnum* StaticEnum<EConcurrencyVolumeScaleMode>()
{
return EConcurrencyVolumeScaleMode_StaticEnum();
}
struct Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics
{
#if WITH_METADATA
static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "Default.Comment", "/* Scales volume of older sounds more than newer sounds (default) */" },
{ "Default.Name", "EConcurrencyVolumeScaleMode::Default" },
{ "Default.ToolTip", "Scales volume of older sounds more than newer sounds (default)" },
{ "Distance.Comment", "/* Scales distant sounds by volume scalar more than closer sounds */" },
{ "Distance.Name", "EConcurrencyVolumeScaleMode::Distance" },
{ "Distance.ToolTip", "Scales distant sounds by volume scalar more than closer sounds" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "Priority.Comment", "/* Scales lower priority sounds by volume scalar more than closer sounds */" },
{ "Priority.Name", "EConcurrencyVolumeScaleMode::Priority" },
{ "Priority.ToolTip", "Scales lower priority sounds by volume scalar more than closer sounds" },
};
#endif // WITH_METADATA
static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EConcurrencyVolumeScaleMode::Default", (int64)EConcurrencyVolumeScaleMode::Default },
{ "EConcurrencyVolumeScaleMode::Distance", (int64)EConcurrencyVolumeScaleMode::Distance },
{ "EConcurrencyVolumeScaleMode::Priority", (int64)EConcurrencyVolumeScaleMode::Priority },
};
static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_Engine,
nullptr,
"EConcurrencyVolumeScaleMode",
"EConcurrencyVolumeScaleMode",
Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::Enumerators,
RF_Public|RF_Transient|RF_MarkAsNative,
UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::Enumerators),
EEnumFlags::None,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode()
{
if (!Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.InnerSingleton)
{
UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.InnerSingleton, Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode_Statics::EnumParams);
}
return Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode.InnerSingleton;
}
// ********** End Enum EConcurrencyVolumeScaleMode *************************************************
// ********** Begin ScriptStruct FSoundConcurrencySettings *****************************************
struct Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics
{
static inline consteval int32 GetStructSize() { return sizeof(FSoundConcurrencySettings); }
static inline consteval int16 GetStructAlignment() { return alignof(FSoundConcurrencySettings); }
#if WITH_METADATA
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MaxCount_MetaData[] = {
{ "Category", "Concurrency" },
{ "ClampMin", "1" },
{ "Comment", "/**\n\x09 * The max number of allowable concurrent active voices for voices playing in this concurrency group.\n\x09 * Can be mutated at runtime via Blueprint or code (see \"Enable MaxCount Platform Scaling\" for disablement\n\x09 * of runtime manipulation, which in turn allows for platform scaling of the given value).\n\x09 */" },
{ "DisplayAfter", "bEnableMaxCountPlatformScaling" },
{ "DisplayName", "Max Count (Dynamic)" },
{ "EditCondition", "!bEnableMaxCountPlatformScaling" },
{ "EditConditionHides", "" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "The max number of allowable concurrent active voices for voices playing in this concurrency group.\nCan be mutated at runtime via Blueprint or code (see \"Enable MaxCount Platform Scaling\" for disablement\nof runtime manipulation, which in turn allows for platform scaling of the given value)." },
{ "UIMin", "1" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bLimitToOwner_MetaData[] = {
{ "Category", "Concurrency" },
{ "Comment", "/* Whether or not to limit the concurrency to per sound owner (i.e. the actor that plays the sound). If the sound doesn't have an owner, it falls back to global concurrency. */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Whether or not to limit the concurrency to per sound owner (i.e. the actor that plays the sound). If the sound doesn't have an owner, it falls back to global concurrency." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bVolumeScaleCanRelease_MetaData[] = {
{ "Category", "Volume Scaling" },
{ "Comment", "/**\n\x09 * Whether or not volume scaling can recover volume ducking behavior when concurrency group sounds stop (default scale mode only).\n\x09 */" },
{ "DisplayAfter", "VolumeScaleMode" },
{ "DisplayName", "Can Recover" },
{ "EditCondition", "VolumeScaleMode == EConcurrencyVolumeScaleMode::Default" },
{ "EditConditionHides", "" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Whether or not volume scaling can recover volume ducking behavior when concurrency group sounds stop (default scale mode only)." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnableMaxCountPlatformScaling_MetaData[] = {
{ "AllowPrivateAccess", "" },
{ "Category", "Concurrency" },
{ "Comment", "/* If true, MaxCount supports platform scaling, but cannot be dynamically changed at runtime (ex. from Blueprint or Gameplay Code). If false, MaxCount is dynamically assignable at runtime, but is not platform scalable. */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "If true, MaxCount supports platform scaling, but cannot be dynamically changed at runtime (ex. from Blueprint or Gameplay Code). If false, MaxCount is dynamically assignable at runtime, but is not platform scalable." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResolutionRule_MetaData[] = {
{ "Category", "Concurrency" },
{ "Comment", "/** Which concurrency resolution policy to use if max voice count is reached. */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Which concurrency resolution policy to use if max voice count is reached." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_RetriggerTime_MetaData[] = {
{ "Category", "Concurrency" },
{ "ClampMin", "0.0" },
{ "Comment", "/** Amount of time to wait (in seconds) between different sounds which play with this concurrency. Sounds rejected from this will ignore virtualization settings. */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Amount of time to wait (in seconds) between different sounds which play with this concurrency. Sounds rejected from this will ignore virtualization settings." },
{ "UIMin", "0.0" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PlatformMaxCount_MetaData[] = {
{ "AllowPrivateAccess", "" },
{ "Category", "Concurrency" },
{ "ClampMin", "1" },
{ "Comment", "/**\n\x09 * The max number of allowable concurrent active voices for voices playing in this concurrency group.\n\x09 * Scalable per platform or platform group. Cannot be mutated at runtime (Disable \"Enable MaxCount Platform\n\x09 * Scaling\" for enablement of MaxCount runtime manipulation).\n\x09 */" },
{ "DisplayAfter", "bEnableMaxCountPlatformScaling" },
{ "DisplayName", "Max Count (Platform Scaled)" },
{ "EditCondition", "bEnableMaxCountPlatformScaling" },
{ "EditConditionHides", "" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "The max number of allowable concurrent active voices for voices playing in this concurrency group.\nScalable per platform or platform group. Cannot be mutated at runtime (Disable \"Enable MaxCount Platform\nScaling\" for enablement of MaxCount runtime manipulation)." },
{ "UIMin", "1" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_VolumeScale_MetaData[] = {
{ "Category", "Volume Scaling" },
{ "ClampMax", "1.0" },
{ "ClampMin", "0.0" },
{ "Comment", "/**\n\x09 * Ducking factor to apply per older voice instance (generation), which compounds based on scaling mode\n\x09 * and (optionally) revives them as they stop according to the provided attack/release times.\n\x09 * \n\x09 * Note: This is not applied until after StopQuietest rules are evaluated, in order to avoid thrashing sounds.\n\x09 *\n\x09 * AppliedVolumeScale = Math.Pow(DuckingScale, VoiceGeneration)\n\x09 */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Ducking factor to apply per older voice instance (generation), which compounds based on scaling mode\nand (optionally) revives them as they stop according to the provided attack/release times.\n\nNote: This is not applied until after StopQuietest rules are evaluated, in order to avoid thrashing sounds.\n\nAppliedVolumeScale = Math.Pow(DuckingScale, VoiceGeneration)" },
{ "UIMax", "1.0" },
{ "UIMin", "0.0" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_VolumeScaleMode_MetaData[] = {
{ "Category", "Volume Scaling" },
{ "Comment", "/** Volume Scale mode designating how to scale voice volume based on number of member sounds active in group. */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Volume Scale mode designating how to scale voice volume based on number of member sounds active in group." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_VolumeScaleAttackTime_MetaData[] = {
{ "Category", "Volume Scaling" },
{ "ClampMax", "1000000.0" },
{ "ClampMin", "0.0" },
{ "Comment", "/**\n\x09 * Time taken to apply duck using volume scalar.\n\x09 */" },
{ "DisplayName", "Duck Time" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Time taken to apply duck using volume scalar." },
{ "UIMax", "10.0" },
{ "UIMin", "0.0" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_VolumeScaleReleaseTime_MetaData[] = {
{ "Category", "Volume Scaling" },
{ "ClampMax", "1000000.0" },
{ "ClampMin", "0.0" },
{ "Comment", "/**\n\x09 * Time taken to recover volume scalar duck (default scale mode only).\n\x09 */" },
{ "DisplayAfter", "bVolumeScaleCanRelease" },
{ "DisplayName", "Recover Time" },
{ "EditCondition", "bVolumeScaleCanRelease && VolumeScaleMode == EConcurrencyVolumeScaleMode::Default" },
{ "EditConditionHides", "" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Time taken to recover volume scalar duck (default scale mode only)." },
{ "UIMax", "10.0" },
{ "UIMin", "0.0" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_VoiceStealReleaseTime_MetaData[] = {
{ "Category", "Voice Stealing" },
{ "ClampMax", "1000000.0" },
{ "ClampMin", "0.0" },
{ "Comment", "/**\n\x09 * Time taken to fade out if voice is evicted or culled due to another voice in the group starting.\n\x09 */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Time taken to fade out if voice is evicted or culled due to another voice in the group starting." },
{ "UIMax", "1.0" },
{ "UIMin", "0.0" },
};
#endif // WITH_METADATA
// ********** Begin ScriptStruct FSoundConcurrencySettings constinit property declarations *********
static const UECodeGen_Private::FIntPropertyParams NewProp_MaxCount;
static void NewProp_bLimitToOwner_SetBit(void* Obj);
static const UECodeGen_Private::FBoolPropertyParams NewProp_bLimitToOwner;
static void NewProp_bVolumeScaleCanRelease_SetBit(void* Obj);
static const UECodeGen_Private::FBoolPropertyParams NewProp_bVolumeScaleCanRelease;
static void NewProp_bEnableMaxCountPlatformScaling_SetBit(void* Obj);
static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableMaxCountPlatformScaling;
static const UECodeGen_Private::FBytePropertyParams NewProp_ResolutionRule;
static const UECodeGen_Private::FFloatPropertyParams NewProp_RetriggerTime;
static const UECodeGen_Private::FStructPropertyParams NewProp_PlatformMaxCount;
static const UECodeGen_Private::FFloatPropertyParams NewProp_VolumeScale;
static const UECodeGen_Private::FIntPropertyParams NewProp_VolumeScaleMode_Underlying;
static const UECodeGen_Private::FEnumPropertyParams NewProp_VolumeScaleMode;
static const UECodeGen_Private::FFloatPropertyParams NewProp_VolumeScaleAttackTime;
static const UECodeGen_Private::FFloatPropertyParams NewProp_VolumeScaleReleaseTime;
static const UECodeGen_Private::FFloatPropertyParams NewProp_VoiceStealReleaseTime;
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FSoundConcurrencySettings constinit property declarations ***********
static void* NewStructOps()
{
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FSoundConcurrencySettings>();
}
static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings;
class UScriptStruct* FSoundConcurrencySettings::StaticStruct()
{
if (!Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.OuterSingleton)
{
Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FSoundConcurrencySettings, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("SoundConcurrencySettings"));
}
return Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.OuterSingleton;
}
// ********** Begin ScriptStruct FSoundConcurrencySettings Property Definitions ********************
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_MaxCount = { "MaxCount", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, MaxCount), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MaxCount_MetaData), NewProp_MaxCount_MetaData) };
void Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bLimitToOwner_SetBit(void* Obj)
{
((FSoundConcurrencySettings*)Obj)->bLimitToOwner = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bLimitToOwner = { "bLimitToOwner", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(uint8), sizeof(FSoundConcurrencySettings), &Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bLimitToOwner_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bLimitToOwner_MetaData), NewProp_bLimitToOwner_MetaData) };
void Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bVolumeScaleCanRelease_SetBit(void* Obj)
{
((FSoundConcurrencySettings*)Obj)->bVolumeScaleCanRelease = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bVolumeScaleCanRelease = { "bVolumeScaleCanRelease", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(uint8), sizeof(FSoundConcurrencySettings), &Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bVolumeScaleCanRelease_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bVolumeScaleCanRelease_MetaData), NewProp_bVolumeScaleCanRelease_MetaData) };
void Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bEnableMaxCountPlatformScaling_SetBit(void* Obj)
{
((FSoundConcurrencySettings*)Obj)->bEnableMaxCountPlatformScaling = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bEnableMaxCountPlatformScaling = { "bEnableMaxCountPlatformScaling", nullptr, (EPropertyFlags)0x0040000000000015, UECodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(uint8), sizeof(FSoundConcurrencySettings), &Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bEnableMaxCountPlatformScaling_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnableMaxCountPlatformScaling_MetaData), NewProp_bEnableMaxCountPlatformScaling_MetaData) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_ResolutionRule = { "ResolutionRule", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, ResolutionRule), Z_Construct_UEnum_Engine_EMaxConcurrentResolutionRule, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResolutionRule_MetaData), NewProp_ResolutionRule_MetaData) }; // 2920592609
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_RetriggerTime = { "RetriggerTime", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, RetriggerTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_RetriggerTime_MetaData), NewProp_RetriggerTime_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_PlatformMaxCount = { "PlatformMaxCount", nullptr, (EPropertyFlags)0x0040000000000015, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, PlatformMaxCount), Z_Construct_UScriptStruct_FPerPlatformInt, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PlatformMaxCount_MetaData), NewProp_PlatformMaxCount_MetaData) }; // 3732958788
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScale = { "VolumeScale", nullptr, (EPropertyFlags)0x0040000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, VolumeScale), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_VolumeScale_MetaData), NewProp_VolumeScale_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleMode = { "VolumeScaleMode", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, VolumeScaleMode), Z_Construct_UEnum_Engine_EConcurrencyVolumeScaleMode, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_VolumeScaleMode_MetaData), NewProp_VolumeScaleMode_MetaData) }; // 214453345
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleAttackTime = { "VolumeScaleAttackTime", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, VolumeScaleAttackTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_VolumeScaleAttackTime_MetaData), NewProp_VolumeScaleAttackTime_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleReleaseTime = { "VolumeScaleReleaseTime", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, VolumeScaleReleaseTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_VolumeScaleReleaseTime_MetaData), NewProp_VolumeScaleReleaseTime_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VoiceStealReleaseTime = { "VoiceStealReleaseTime", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FSoundConcurrencySettings, VoiceStealReleaseTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_VoiceStealReleaseTime_MetaData), NewProp_VoiceStealReleaseTime_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::PropPointers[] = {
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_MaxCount,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bLimitToOwner,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bVolumeScaleCanRelease,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_bEnableMaxCountPlatformScaling,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_ResolutionRule,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_RetriggerTime,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_PlatformMaxCount,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScale,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleMode_Underlying,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleMode,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleAttackTime,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VolumeScaleReleaseTime,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewProp_VoiceStealReleaseTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FSoundConcurrencySettings Property Definitions **********************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::StructParams = {
(UObject* (*)())Z_Construct_UPackage__Script_Engine,
nullptr,
&NewStructOps,
"SoundConcurrencySettings",
Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::PropPointers,
UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::PropPointers),
sizeof(FSoundConcurrencySettings),
alignof(FSoundConcurrencySettings),
RF_Public|RF_Transient|RF_MarkAsNative,
EStructFlags(0x00000001),
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FSoundConcurrencySettings()
{
if (!Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.InnerSingleton)
{
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.InnerSingleton, Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::StructParams);
}
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings.InnerSingleton);
}
// ********** End ScriptStruct FSoundConcurrencySettings *******************************************
// ********** Begin Class USoundConcurrency Function SetMaxCount ***********************************
struct Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics
{
struct SoundConcurrency_eventSetMaxCount_Parms
{
int32 InMaxCount;
bool ReturnValue;
};
#if WITH_METADATA
static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
{ "Category", "Concurrency" },
{ "Comment", "/**\n\x09 * Applies the given integer value as the group's MaxCount if passed valid MaxCount (greater than 0) and MaxCount platform scaling is enabled.\n\x09 * Returns true if successfully set, false if not.\n\x09 */" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ToolTip", "Applies the given integer value as the group's MaxCount if passed valid MaxCount (greater than 0) and MaxCount platform scaling is enabled.\nReturns true if successfully set, false if not." },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_InMaxCount_MetaData[] = {
{ "DisplayName", "MaxCount" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ReturnValue_MetaData[] = {
{ "DisplayName", "Success" },
};
#endif // WITH_METADATA
// ********** Begin Function SetMaxCount constinit property declarations ***************************
static const UECodeGen_Private::FIntPropertyParams NewProp_InMaxCount;
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function SetMaxCount constinit property declarations *****************************
static const UECodeGen_Private::FFunctionParams FuncParams;
};
// ********** Begin Function SetMaxCount Property Definitions **************************************
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_InMaxCount = { "InMaxCount", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(SoundConcurrency_eventSetMaxCount_Parms, InMaxCount), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_InMaxCount_MetaData), NewProp_InMaxCount_MetaData) };
void Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((SoundConcurrency_eventSetMaxCount_Parms*)Obj)->ReturnValue = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(SoundConcurrency_eventSetMaxCount_Parms), &Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ReturnValue_MetaData), NewProp_ReturnValue_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::PropPointers[] = {
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_InMaxCount,
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::PropPointers) < 2048);
// ********** End Function SetMaxCount Property Definitions ****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_USoundConcurrency, nullptr, "SetMaxCount", Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::PropPointers,
UE_ARRAY_COUNT(Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::PropPointers),
sizeof(Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::SoundConcurrency_eventSetMaxCount_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::Function_MetaDataParams), Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::Function_MetaDataParams)}, };
static_assert(sizeof(Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::SoundConcurrency_eventSetMaxCount_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_USoundConcurrency_SetMaxCount()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_USoundConcurrency_SetMaxCount_Statics::FuncParams);
}
return ReturnFunction;
}
DEFINE_FUNCTION(USoundConcurrency::execSetMaxCount)
{
P_GET_PROPERTY(FIntProperty,Z_Param_InMaxCount);
P_FINISH;
P_NATIVE_BEGIN;
*(bool*)Z_Param__Result=P_THIS->SetMaxCount(Z_Param_InMaxCount);
P_NATIVE_END;
}
// ********** End Class USoundConcurrency Function SetMaxCount *************************************
// ********** Begin Class USoundConcurrency ********************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_USoundConcurrency;
UClass* USoundConcurrency::GetPrivateStaticClass()
{
using TClass = USoundConcurrency;
if (!Z_Registration_Info_UClass_USoundConcurrency.InnerSingleton)
{
GetPrivateStaticClassBody(
TClass::StaticPackage(),
TEXT("SoundConcurrency"),
Z_Registration_Info_UClass_USoundConcurrency.InnerSingleton,
StaticRegisterNativesUSoundConcurrency,
sizeof(TClass),
alignof(TClass),
TClass::StaticClassFlags,
TClass::StaticClassCastFlags(),
TClass::StaticConfigName(),
(UClass::ClassConstructorType)InternalConstructor<TClass>,
(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
&TClass::Super::StaticClass,
&TClass::WithinClass::StaticClass
);
}
return Z_Registration_Info_UClass_USoundConcurrency.InnerSingleton;
}
UClass* Z_Construct_UClass_USoundConcurrency_NoRegister()
{
return USoundConcurrency::GetPrivateStaticClass();
}
struct Z_Construct_UClass_USoundConcurrency_Statics
{
#if WITH_METADATA
static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "HideCategories", "Object" },
{ "IncludePath", "Sound/SoundConcurrency.h" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
};
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Concurrency_MetaData[] = {
{ "Category", "Settings" },
{ "ModuleRelativePath", "Classes/Sound/SoundConcurrency.h" },
{ "ShowOnlyInnerProperties", "" },
};
#endif // WITH_METADATA
// ********** Begin Class USoundConcurrency constinit property declarations ************************
static const UECodeGen_Private::FStructPropertyParams NewProp_Concurrency;
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class USoundConcurrency constinit property declarations **************************
static constexpr UE::CodeGen::FClassNativeFunction Funcs[] = {
{ .NameUTF8 = UTF8TEXT("SetMaxCount"), .Pointer = &USoundConcurrency::execSetMaxCount },
};
static UObject* (*const DependentSingletons[])();
static constexpr FClassFunctionLinkInfo FuncInfo[] = {
{ &Z_Construct_UFunction_USoundConcurrency_SetMaxCount, "SetMaxCount" }, // 2928357537
};
static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
TCppClassTypeTraits<USoundConcurrency>::IsAbstract,
};
static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_USoundConcurrency_Statics
// ********** Begin Class USoundConcurrency Property Definitions ***********************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_USoundConcurrency_Statics::NewProp_Concurrency = { "Concurrency", nullptr, (EPropertyFlags)0x0010000000000015, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(USoundConcurrency, Concurrency), Z_Construct_UScriptStruct_FSoundConcurrencySettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Concurrency_MetaData), NewProp_Concurrency_MetaData) }; // 1011771374
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USoundConcurrency_Statics::PropPointers[] = {
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USoundConcurrency_Statics::NewProp_Concurrency,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_USoundConcurrency_Statics::PropPointers) < 2048);
// ********** End Class USoundConcurrency Property Definitions *************************************
UObject* (*const Z_Construct_UClass_USoundConcurrency_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UObject,
(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_USoundConcurrency_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_USoundConcurrency_Statics::ClassParams = {
&USoundConcurrency::StaticClass,
nullptr,
&StaticCppClassTypeInfo,
DependentSingletons,
FuncInfo,
Z_Construct_UClass_USoundConcurrency_Statics::PropPointers,
nullptr,
UE_ARRAY_COUNT(DependentSingletons),
UE_ARRAY_COUNT(FuncInfo),
UE_ARRAY_COUNT(Z_Construct_UClass_USoundConcurrency_Statics::PropPointers),
0,
0x000810A0u,
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_USoundConcurrency_Statics::Class_MetaDataParams), Z_Construct_UClass_USoundConcurrency_Statics::Class_MetaDataParams)
};
void USoundConcurrency::StaticRegisterNativesUSoundConcurrency()
{
UClass* Class = USoundConcurrency::StaticClass();
FNativeFunctionRegistrar::RegisterFunctions(Class, MakeConstArrayView(Z_Construct_UClass_USoundConcurrency_Statics::Funcs));
}
UClass* Z_Construct_UClass_USoundConcurrency()
{
if (!Z_Registration_Info_UClass_USoundConcurrency.OuterSingleton)
{
UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_USoundConcurrency.OuterSingleton, Z_Construct_UClass_USoundConcurrency_Statics::ClassParams);
}
return Z_Registration_Info_UClass_USoundConcurrency.OuterSingleton;
}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, USoundConcurrency);
USoundConcurrency::~USoundConcurrency() {}
// ********** End Class USoundConcurrency **********************************************************
// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics
{
static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
{ EMaxConcurrentResolutionRule_StaticEnum, TEXT("EMaxConcurrentResolutionRule"), &Z_Registration_Info_UEnum_EMaxConcurrentResolutionRule, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2920592609U) },
{ EConcurrencyVolumeScaleMode_StaticEnum, TEXT("EConcurrencyVolumeScaleMode"), &Z_Registration_Info_UEnum_EConcurrencyVolumeScaleMode, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 214453345U) },
};
static constexpr FStructRegisterCompiledInInfo ScriptStructInfo[] = {
{ FSoundConcurrencySettings::StaticStruct, Z_Construct_UScriptStruct_FSoundConcurrencySettings_Statics::NewStructOps, TEXT("SoundConcurrencySettings"),&Z_Registration_Info_UScriptStruct_FSoundConcurrencySettings, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FSoundConcurrencySettings), 1011771374U) },
};
static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
{ Z_Construct_UClass_USoundConcurrency, USoundConcurrency::StaticClass, TEXT("USoundConcurrency"), &Z_Registration_Info_UClass_USoundConcurrency, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(USoundConcurrency), 3784146061U) },
};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_897673493{
TEXT("/Script/Engine"),
Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::ClassInfo),
Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::ScriptStructInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::ScriptStructInfo),
Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Sound_SoundConcurrency_h__Script_Engine_Statics::EnumInfo),
};
// ********** End Registration *********************************************************************
PRAGMA_ENABLE_DEPRECATION_WARNINGS
Reference in New Issue Copy Permalink