1927 lines
129 KiB
C++
1927 lines
129 KiB
C++
// 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 "RigVMCore/RigVMByteCode.h"
|
|
#include "RigVMCore/RigVMMemoryStorage.h"
|
|
#include "UObject/TopLevelAssetPath.h"
|
|
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
static_assert(!UE_WITH_CONSTINIT_UOBJECT, "This generated code can only be compiled with !UE_WITH_CONSTINIT_OBJECT");
|
|
void EmptyLinkFunctionForGeneratedCodeRigVMByteCode() {}
|
|
|
|
// ********** Begin Cross Module References ********************************************************
|
|
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FTopLevelAssetPath();
|
|
RIGVM_API UEnum* Z_Construct_UEnum_RigVM_ERigVMCopyType();
|
|
RIGVM_API UEnum* Z_Construct_UEnum_RigVM_ERigVMOpCode();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMBaseOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMBinaryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMBranchInfo();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMByteCode();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMByteCodeEntry();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMChangeTypeOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMComparisonOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMCopyOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMExecuteOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMInstruction();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMInstructionArray();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMInvokeEntryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpIfOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpToBranchOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMPredicateBranch();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMQuaternaryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMQuinaryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMRunInstructionsOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMSenaryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMSetupTraitsOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMTernaryOp();
|
|
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMUnaryOp();
|
|
UPackage* Z_Construct_UPackage__Script_RigVM();
|
|
// ********** End Cross Module References **********************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMPredicateBranch *********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMPredicateBranch); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMPredicateBranch); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// A description of a predicate branch in the VM's bytecode\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "A description of a predicate branch in the VM's bytecode" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMPredicateBranch constinit property declarations *************
|
|
// ********** End ScriptStruct FRigVMPredicateBranch constinit property declarations ***************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMPredicateBranch>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch;
|
|
class UScriptStruct* FRigVMPredicateBranch::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMPredicateBranch, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMPredicateBranch"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMPredicateBranch",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMPredicateBranch),
|
|
alignof(FRigVMPredicateBranch),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMPredicateBranch()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.InnerSingleton, Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMPredicateBranch ***********************************************
|
|
|
|
// ********** Begin Enum ERigVMOpCode **************************************************************
|
|
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ERigVMOpCode;
|
|
static UEnum* ERigVMOpCode_StaticEnum()
|
|
{
|
|
if (!Z_Registration_Info_UEnum_ERigVMOpCode.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UEnum_ERigVMOpCode.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_RigVM_ERigVMOpCode, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("ERigVMOpCode"));
|
|
}
|
|
return Z_Registration_Info_UEnum_ERigVMOpCode.OuterSingleton;
|
|
}
|
|
template<> RIGVM_NON_ATTRIBUTED_API UEnum* StaticEnum<ERigVMOpCode>()
|
|
{
|
|
return ERigVMOpCode_StaticEnum();
|
|
}
|
|
struct Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics
|
|
{
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
|
|
{ "ArrayAdd.Comment", "// (DEPRECATED) sets an array element by index (ternary op, in out array, in int32, in element)\n" },
|
|
{ "ArrayAdd.Name", "ERigVMOpCode::ArrayAdd" },
|
|
{ "ArrayAdd.ToolTip", "(DEPRECATED) sets an array element by index (ternary op, in out array, in int32, in element)" },
|
|
{ "ArrayAppend.Comment", "// (DEPRECATED) finds and returns the index of an element (quaternery op, in array, in element, out int32 index, out bool success)\n" },
|
|
{ "ArrayAppend.Name", "ERigVMOpCode::ArrayAppend" },
|
|
{ "ArrayAppend.ToolTip", "(DEPRECATED) finds and returns the index of an element (quaternery op, in array, in element, out int32 index, out bool success)" },
|
|
{ "ArrayClone.Comment", "// (DEPRECATED) appends an array to another (binary op, in out array, in array)\n" },
|
|
{ "ArrayClone.Name", "ERigVMOpCode::ArrayClone" },
|
|
{ "ArrayClone.ToolTip", "(DEPRECATED) appends an array to another (binary op, in out array, in array)" },
|
|
{ "ArrayDifference.Comment", "// (DEPRECATED) merges two arrays while avoiding duplicates (binary op, in out array, in other array)\n" },
|
|
{ "ArrayDifference.Name", "ERigVMOpCode::ArrayDifference" },
|
|
{ "ArrayDifference.ToolTip", "(DEPRECATED) merges two arrays while avoiding duplicates (binary op, in out array, in other array)" },
|
|
{ "ArrayFind.Comment", "// (DEPRECATED) removes an element from an array (binary op, in out array, in inindex)\n" },
|
|
{ "ArrayFind.Name", "ERigVMOpCode::ArrayFind" },
|
|
{ "ArrayFind.ToolTip", "(DEPRECATED) removes an element from an array (binary op, in out array, in inindex)" },
|
|
{ "ArrayGetAtIndex.Comment", "// (DEPRECATED) resizes an array (binary op, in out array, in int32)\n" },
|
|
{ "ArrayGetAtIndex.Name", "ERigVMOpCode::ArrayGetAtIndex" },
|
|
{ "ArrayGetAtIndex.ToolTip", "(DEPRECATED) resizes an array (binary op, in out array, in int32)" },
|
|
{ "ArrayGetNum.Comment", "// (DEPRECATED) clears an array and resets its content\n" },
|
|
{ "ArrayGetNum.Name", "ERigVMOpCode::ArrayGetNum" },
|
|
{ "ArrayGetNum.ToolTip", "(DEPRECATED) clears an array and resets its content" },
|
|
{ "ArrayInsert.Comment", "// (DEPRECATED) adds an element to an array (ternary op, in out array, in element, out int32 index)\n" },
|
|
{ "ArrayInsert.Name", "ERigVMOpCode::ArrayInsert" },
|
|
{ "ArrayInsert.ToolTip", "(DEPRECATED) adds an element to an array (ternary op, in out array, in element, out int32 index)" },
|
|
{ "ArrayIntersection.Comment", "// (DEPRECATED) returns a new array containing elements only found in one array (ternary op, in array, in array, out result)\n" },
|
|
{ "ArrayIntersection.Name", "ERigVMOpCode::ArrayIntersection" },
|
|
{ "ArrayIntersection.ToolTip", "(DEPRECATED) returns a new array containing elements only found in one array (ternary op, in array, in array, out result)" },
|
|
{ "ArrayIterator.Comment", "// (DEPRECATED) clones an array (binary op, in array, out array)\n" },
|
|
{ "ArrayIterator.Name", "ERigVMOpCode::ArrayIterator" },
|
|
{ "ArrayIterator.ToolTip", "(DEPRECATED) clones an array (binary op, in array, out array)" },
|
|
{ "ArrayRemove.Comment", "// (DEPRECATED) inserts an element to an array (ternary op, in out array, in int32, in element)\n" },
|
|
{ "ArrayRemove.Name", "ERigVMOpCode::ArrayRemove" },
|
|
{ "ArrayRemove.ToolTip", "(DEPRECATED) inserts an element to an array (ternary op, in out array, in int32, in element)" },
|
|
{ "ArrayReset.Comment", "// ends the last memory slice / block\n" },
|
|
{ "ArrayReset.Name", "ERigVMOpCode::ArrayReset" },
|
|
{ "ArrayReset.ToolTip", "ends the last memory slice / block" },
|
|
{ "ArrayReverse.Comment", "// (DEPRECATED) returns a new array containing elements found in both of the input arrays (ternary op, in array, in array, out result)\n" },
|
|
{ "ArrayReverse.Name", "ERigVMOpCode::ArrayReverse" },
|
|
{ "ArrayReverse.ToolTip", "(DEPRECATED) returns a new array containing elements found in both of the input arrays (ternary op, in array, in array, out result)" },
|
|
{ "ArraySetAtIndex.Comment", "// (DEPRECATED) returns an array element by index (ternary op, in array, in int32, out element) \n" },
|
|
{ "ArraySetAtIndex.Name", "ERigVMOpCode::ArraySetAtIndex" },
|
|
{ "ArraySetAtIndex.ToolTip", "(DEPRECATED) returns an array element by index (ternary op, in array, in int32, out element)" },
|
|
{ "ArraySetNum.Comment", "// (DEPRECATED) reads and returns the size of an array (binary op, in array, out int32) \n" },
|
|
{ "ArraySetNum.Name", "ERigVMOpCode::ArraySetNum" },
|
|
{ "ArraySetNum.ToolTip", "(DEPRECATED) reads and returns the size of an array (binary op, in array, out int32)" },
|
|
{ "ArrayUnion.Comment", "// (DEPRECATED) iterates over an array (senary op, in array, out element, out index, out count, out ratio, out continue)\n" },
|
|
{ "ArrayUnion.Name", "ERigVMOpCode::ArrayUnion" },
|
|
{ "ArrayUnion.ToolTip", "(DEPRECATED) iterates over an array (senary op, in array, out element, out index, out count, out ratio, out continue)" },
|
|
{ "BeginBlock.Comment", "// exit the execution loop\n" },
|
|
{ "BeginBlock.Name", "ERigVMOpCode::BeginBlock" },
|
|
{ "BeginBlock.ToolTip", "exit the execution loop" },
|
|
{ "BoolFalse.Comment", "// zero the memory of a given register\n" },
|
|
{ "BoolFalse.Name", "ERigVMOpCode::BoolFalse" },
|
|
{ "BoolFalse.ToolTip", "zero the memory of a given register" },
|
|
{ "BoolTrue.Comment", "// set a given register to false\n" },
|
|
{ "BoolTrue.Name", "ERigVMOpCode::BoolTrue" },
|
|
{ "BoolTrue.ToolTip", "set a given register to false" },
|
|
{ "ChangeType.Comment", "// jump backwards given a relative instruction index offset based on a condition register\n" },
|
|
{ "ChangeType.Name", "ERigVMOpCode::ChangeType" },
|
|
{ "ChangeType.ToolTip", "jump backwards given a relative instruction index offset based on a condition register" },
|
|
{ "Comment", "// The code for a single operation within the RigVM\n" },
|
|
{ "Copy.Comment", "// set a given register to true\n" },
|
|
{ "Copy.Name", "ERigVMOpCode::Copy" },
|
|
{ "Copy.ToolTip", "set a given register to true" },
|
|
{ "Decrement.Comment", "// increment a int32 register\n" },
|
|
{ "Decrement.Name", "ERigVMOpCode::Decrement" },
|
|
{ "Decrement.ToolTip", "increment a int32 register" },
|
|
{ "EndBlock.Comment", "// begins a new memory slice / block\n" },
|
|
{ "EndBlock.Name", "ERigVMOpCode::EndBlock" },
|
|
{ "EndBlock.ToolTip", "begins a new memory slice / block" },
|
|
{ "Equals.Comment", "// decrement a int32 register\n" },
|
|
{ "Equals.Name", "ERigVMOpCode::Equals" },
|
|
{ "Equals.ToolTip", "decrement a int32 register" },
|
|
{ "Execute.Comment", "// jumps to a branch based on a name operand\n" },
|
|
{ "Execute.Name", "ERigVMOpCode::Execute" },
|
|
{ "Execute.ToolTip", "jumps to a branch based on a name operand" },
|
|
{ "Execute_0_Operands.Name", "ERigVMOpCode::Execute_0_Operands" },
|
|
{ "Execute_10_Operands.Comment", "// (DEPRECATED) execute a rig function with 9 operands\n" },
|
|
{ "Execute_10_Operands.Name", "ERigVMOpCode::Execute_10_Operands" },
|
|
{ "Execute_10_Operands.ToolTip", "(DEPRECATED) execute a rig function with 9 operands" },
|
|
{ "Execute_11_Operands.Comment", "// (DEPRECATED) execute a rig function with 10 operands\n" },
|
|
{ "Execute_11_Operands.Name", "ERigVMOpCode::Execute_11_Operands" },
|
|
{ "Execute_11_Operands.ToolTip", "(DEPRECATED) execute a rig function with 10 operands" },
|
|
{ "Execute_12_Operands.Comment", "// (DEPRECATED) execute a rig function with 11 operands\n" },
|
|
{ "Execute_12_Operands.Name", "ERigVMOpCode::Execute_12_Operands" },
|
|
{ "Execute_12_Operands.ToolTip", "(DEPRECATED) execute a rig function with 11 operands" },
|
|
{ "Execute_13_Operands.Comment", "// (DEPRECATED) execute a rig function with 12 operands\n" },
|
|
{ "Execute_13_Operands.Name", "ERigVMOpCode::Execute_13_Operands" },
|
|
{ "Execute_13_Operands.ToolTip", "(DEPRECATED) execute a rig function with 12 operands" },
|
|
{ "Execute_14_Operands.Comment", "// (DEPRECATED) execute a rig function with 13 operands\n" },
|
|
{ "Execute_14_Operands.Name", "ERigVMOpCode::Execute_14_Operands" },
|
|
{ "Execute_14_Operands.ToolTip", "(DEPRECATED) execute a rig function with 13 operands" },
|
|
{ "Execute_15_Operands.Comment", "// (DEPRECATED) execute a rig function with 14 operands\n" },
|
|
{ "Execute_15_Operands.Name", "ERigVMOpCode::Execute_15_Operands" },
|
|
{ "Execute_15_Operands.ToolTip", "(DEPRECATED) execute a rig function with 14 operands" },
|
|
{ "Execute_16_Operands.Comment", "// (DEPRECATED) execute a rig function with 15 operands\n" },
|
|
{ "Execute_16_Operands.Name", "ERigVMOpCode::Execute_16_Operands" },
|
|
{ "Execute_16_Operands.ToolTip", "(DEPRECATED) execute a rig function with 15 operands" },
|
|
{ "Execute_17_Operands.Comment", "// (DEPRECATED) execute a rig function with 16 operands\n" },
|
|
{ "Execute_17_Operands.Name", "ERigVMOpCode::Execute_17_Operands" },
|
|
{ "Execute_17_Operands.ToolTip", "(DEPRECATED) execute a rig function with 16 operands" },
|
|
{ "Execute_18_Operands.Comment", "// (DEPRECATED) execute a rig function with 17 operands\n" },
|
|
{ "Execute_18_Operands.Name", "ERigVMOpCode::Execute_18_Operands" },
|
|
{ "Execute_18_Operands.ToolTip", "(DEPRECATED) execute a rig function with 17 operands" },
|
|
{ "Execute_19_Operands.Comment", "// (DEPRECATED) execute a rig function with 18 operands\n" },
|
|
{ "Execute_19_Operands.Name", "ERigVMOpCode::Execute_19_Operands" },
|
|
{ "Execute_19_Operands.ToolTip", "(DEPRECATED) execute a rig function with 18 operands" },
|
|
{ "Execute_1_Operands.Comment", "// (DEPRECATED) execute a rig function with 0 operands\n" },
|
|
{ "Execute_1_Operands.Name", "ERigVMOpCode::Execute_1_Operands" },
|
|
{ "Execute_1_Operands.ToolTip", "(DEPRECATED) execute a rig function with 0 operands" },
|
|
{ "Execute_20_Operands.Comment", "// (DEPRECATED) execute a rig function with 19 operands\n" },
|
|
{ "Execute_20_Operands.Name", "ERigVMOpCode::Execute_20_Operands" },
|
|
{ "Execute_20_Operands.ToolTip", "(DEPRECATED) execute a rig function with 19 operands" },
|
|
{ "Execute_21_Operands.Comment", "// (DEPRECATED) execute a rig function with 20 operands\n" },
|
|
{ "Execute_21_Operands.Name", "ERigVMOpCode::Execute_21_Operands" },
|
|
{ "Execute_21_Operands.ToolTip", "(DEPRECATED) execute a rig function with 20 operands" },
|
|
{ "Execute_22_Operands.Comment", "// (DEPRECATED) execute a rig function with 21 operands\n" },
|
|
{ "Execute_22_Operands.Name", "ERigVMOpCode::Execute_22_Operands" },
|
|
{ "Execute_22_Operands.ToolTip", "(DEPRECATED) execute a rig function with 21 operands" },
|
|
{ "Execute_23_Operands.Comment", "// (DEPRECATED) execute a rig function with 22 operands\n" },
|
|
{ "Execute_23_Operands.Name", "ERigVMOpCode::Execute_23_Operands" },
|
|
{ "Execute_23_Operands.ToolTip", "(DEPRECATED) execute a rig function with 22 operands" },
|
|
{ "Execute_24_Operands.Comment", "// (DEPRECATED) execute a rig function with 23 operands\n" },
|
|
{ "Execute_24_Operands.Name", "ERigVMOpCode::Execute_24_Operands" },
|
|
{ "Execute_24_Operands.ToolTip", "(DEPRECATED) execute a rig function with 23 operands" },
|
|
{ "Execute_25_Operands.Comment", "// (DEPRECATED) execute a rig function with 24 operands\n" },
|
|
{ "Execute_25_Operands.Name", "ERigVMOpCode::Execute_25_Operands" },
|
|
{ "Execute_25_Operands.ToolTip", "(DEPRECATED) execute a rig function with 24 operands" },
|
|
{ "Execute_26_Operands.Comment", "// (DEPRECATED) execute a rig function with 25 operands\n" },
|
|
{ "Execute_26_Operands.Name", "ERigVMOpCode::Execute_26_Operands" },
|
|
{ "Execute_26_Operands.ToolTip", "(DEPRECATED) execute a rig function with 25 operands" },
|
|
{ "Execute_27_Operands.Comment", "// (DEPRECATED) execute a rig function with 26 operands\n" },
|
|
{ "Execute_27_Operands.Name", "ERigVMOpCode::Execute_27_Operands" },
|
|
{ "Execute_27_Operands.ToolTip", "(DEPRECATED) execute a rig function with 26 operands" },
|
|
{ "Execute_28_Operands.Comment", "// (DEPRECATED) execute a rig function with 27 operands\n" },
|
|
{ "Execute_28_Operands.Name", "ERigVMOpCode::Execute_28_Operands" },
|
|
{ "Execute_28_Operands.ToolTip", "(DEPRECATED) execute a rig function with 27 operands" },
|
|
{ "Execute_29_Operands.Comment", "// (DEPRECATED) execute a rig function with 28 operands\n" },
|
|
{ "Execute_29_Operands.Name", "ERigVMOpCode::Execute_29_Operands" },
|
|
{ "Execute_29_Operands.ToolTip", "(DEPRECATED) execute a rig function with 28 operands" },
|
|
{ "Execute_2_Operands.Comment", "// (DEPRECATED) execute a rig function with 1 operands\n" },
|
|
{ "Execute_2_Operands.Name", "ERigVMOpCode::Execute_2_Operands" },
|
|
{ "Execute_2_Operands.ToolTip", "(DEPRECATED) execute a rig function with 1 operands" },
|
|
{ "Execute_30_Operands.Comment", "// (DEPRECATED) execute a rig function with 29 operands\n" },
|
|
{ "Execute_30_Operands.Name", "ERigVMOpCode::Execute_30_Operands" },
|
|
{ "Execute_30_Operands.ToolTip", "(DEPRECATED) execute a rig function with 29 operands" },
|
|
{ "Execute_31_Operands.Comment", "// (DEPRECATED) execute a rig function with 30 operands\n" },
|
|
{ "Execute_31_Operands.Name", "ERigVMOpCode::Execute_31_Operands" },
|
|
{ "Execute_31_Operands.ToolTip", "(DEPRECATED) execute a rig function with 30 operands" },
|
|
{ "Execute_32_Operands.Comment", "// (DEPRECATED) execute a rig function with 31 operands\n" },
|
|
{ "Execute_32_Operands.Name", "ERigVMOpCode::Execute_32_Operands" },
|
|
{ "Execute_32_Operands.ToolTip", "(DEPRECATED) execute a rig function with 31 operands" },
|
|
{ "Execute_33_Operands.Comment", "// (DEPRECATED) execute a rig function with 32 operands\n" },
|
|
{ "Execute_33_Operands.Name", "ERigVMOpCode::Execute_33_Operands" },
|
|
{ "Execute_33_Operands.ToolTip", "(DEPRECATED) execute a rig function with 32 operands" },
|
|
{ "Execute_34_Operands.Comment", "// (DEPRECATED) execute a rig function with 33 operands\n" },
|
|
{ "Execute_34_Operands.Name", "ERigVMOpCode::Execute_34_Operands" },
|
|
{ "Execute_34_Operands.ToolTip", "(DEPRECATED) execute a rig function with 33 operands" },
|
|
{ "Execute_35_Operands.Comment", "// (DEPRECATED) execute a rig function with 34 operands\n" },
|
|
{ "Execute_35_Operands.Name", "ERigVMOpCode::Execute_35_Operands" },
|
|
{ "Execute_35_Operands.ToolTip", "(DEPRECATED) execute a rig function with 34 operands" },
|
|
{ "Execute_36_Operands.Comment", "// (DEPRECATED) execute a rig function with 35 operands\n" },
|
|
{ "Execute_36_Operands.Name", "ERigVMOpCode::Execute_36_Operands" },
|
|
{ "Execute_36_Operands.ToolTip", "(DEPRECATED) execute a rig function with 35 operands" },
|
|
{ "Execute_37_Operands.Comment", "// (DEPRECATED) execute a rig function with 36 operands\n" },
|
|
{ "Execute_37_Operands.Name", "ERigVMOpCode::Execute_37_Operands" },
|
|
{ "Execute_37_Operands.ToolTip", "(DEPRECATED) execute a rig function with 36 operands" },
|
|
{ "Execute_38_Operands.Comment", "// (DEPRECATED) execute a rig function with 37 operands\n" },
|
|
{ "Execute_38_Operands.Name", "ERigVMOpCode::Execute_38_Operands" },
|
|
{ "Execute_38_Operands.ToolTip", "(DEPRECATED) execute a rig function with 37 operands" },
|
|
{ "Execute_39_Operands.Comment", "// (DEPRECATED) execute a rig function with 38 operands\n" },
|
|
{ "Execute_39_Operands.Name", "ERigVMOpCode::Execute_39_Operands" },
|
|
{ "Execute_39_Operands.ToolTip", "(DEPRECATED) execute a rig function with 38 operands" },
|
|
{ "Execute_3_Operands.Comment", "// (DEPRECATED) execute a rig function with 2 operands\n" },
|
|
{ "Execute_3_Operands.Name", "ERigVMOpCode::Execute_3_Operands" },
|
|
{ "Execute_3_Operands.ToolTip", "(DEPRECATED) execute a rig function with 2 operands" },
|
|
{ "Execute_40_Operands.Comment", "// (DEPRECATED) execute a rig function with 39 operands\n" },
|
|
{ "Execute_40_Operands.Name", "ERigVMOpCode::Execute_40_Operands" },
|
|
{ "Execute_40_Operands.ToolTip", "(DEPRECATED) execute a rig function with 39 operands" },
|
|
{ "Execute_41_Operands.Comment", "// (DEPRECATED) execute a rig function with 40 operands\n" },
|
|
{ "Execute_41_Operands.Name", "ERigVMOpCode::Execute_41_Operands" },
|
|
{ "Execute_41_Operands.ToolTip", "(DEPRECATED) execute a rig function with 40 operands" },
|
|
{ "Execute_42_Operands.Comment", "// (DEPRECATED) execute a rig function with 41 operands\n" },
|
|
{ "Execute_42_Operands.Name", "ERigVMOpCode::Execute_42_Operands" },
|
|
{ "Execute_42_Operands.ToolTip", "(DEPRECATED) execute a rig function with 41 operands" },
|
|
{ "Execute_43_Operands.Comment", "// (DEPRECATED) execute a rig function with 42 operands\n" },
|
|
{ "Execute_43_Operands.Name", "ERigVMOpCode::Execute_43_Operands" },
|
|
{ "Execute_43_Operands.ToolTip", "(DEPRECATED) execute a rig function with 42 operands" },
|
|
{ "Execute_44_Operands.Comment", "// (DEPRECATED) execute a rig function with 43 operands\n" },
|
|
{ "Execute_44_Operands.Name", "ERigVMOpCode::Execute_44_Operands" },
|
|
{ "Execute_44_Operands.ToolTip", "(DEPRECATED) execute a rig function with 43 operands" },
|
|
{ "Execute_45_Operands.Comment", "// (DEPRECATED) execute a rig function with 44 operands\n" },
|
|
{ "Execute_45_Operands.Name", "ERigVMOpCode::Execute_45_Operands" },
|
|
{ "Execute_45_Operands.ToolTip", "(DEPRECATED) execute a rig function with 44 operands" },
|
|
{ "Execute_46_Operands.Comment", "// (DEPRECATED) execute a rig function with 45 operands\n" },
|
|
{ "Execute_46_Operands.Name", "ERigVMOpCode::Execute_46_Operands" },
|
|
{ "Execute_46_Operands.ToolTip", "(DEPRECATED) execute a rig function with 45 operands" },
|
|
{ "Execute_47_Operands.Comment", "// (DEPRECATED) execute a rig function with 46 operands\n" },
|
|
{ "Execute_47_Operands.Name", "ERigVMOpCode::Execute_47_Operands" },
|
|
{ "Execute_47_Operands.ToolTip", "(DEPRECATED) execute a rig function with 46 operands" },
|
|
{ "Execute_48_Operands.Comment", "// (DEPRECATED) execute a rig function with 47 operands\n" },
|
|
{ "Execute_48_Operands.Name", "ERigVMOpCode::Execute_48_Operands" },
|
|
{ "Execute_48_Operands.ToolTip", "(DEPRECATED) execute a rig function with 47 operands" },
|
|
{ "Execute_49_Operands.Comment", "// (DEPRECATED) execute a rig function with 48 operands\n" },
|
|
{ "Execute_49_Operands.Name", "ERigVMOpCode::Execute_49_Operands" },
|
|
{ "Execute_49_Operands.ToolTip", "(DEPRECATED) execute a rig function with 48 operands" },
|
|
{ "Execute_4_Operands.Comment", "// (DEPRECATED) execute a rig function with 3 operands\n" },
|
|
{ "Execute_4_Operands.Name", "ERigVMOpCode::Execute_4_Operands" },
|
|
{ "Execute_4_Operands.ToolTip", "(DEPRECATED) execute a rig function with 3 operands" },
|
|
{ "Execute_50_Operands.Comment", "// (DEPRECATED) execute a rig function with 49 operands\n" },
|
|
{ "Execute_50_Operands.Name", "ERigVMOpCode::Execute_50_Operands" },
|
|
{ "Execute_50_Operands.ToolTip", "(DEPRECATED) execute a rig function with 49 operands" },
|
|
{ "Execute_51_Operands.Comment", "// (DEPRECATED) execute a rig function with 50 operands\n" },
|
|
{ "Execute_51_Operands.Name", "ERigVMOpCode::Execute_51_Operands" },
|
|
{ "Execute_51_Operands.ToolTip", "(DEPRECATED) execute a rig function with 50 operands" },
|
|
{ "Execute_52_Operands.Comment", "// (DEPRECATED) execute a rig function with 51 operands\n" },
|
|
{ "Execute_52_Operands.Name", "ERigVMOpCode::Execute_52_Operands" },
|
|
{ "Execute_52_Operands.ToolTip", "(DEPRECATED) execute a rig function with 51 operands" },
|
|
{ "Execute_53_Operands.Comment", "// (DEPRECATED) execute a rig function with 52 operands\n" },
|
|
{ "Execute_53_Operands.Name", "ERigVMOpCode::Execute_53_Operands" },
|
|
{ "Execute_53_Operands.ToolTip", "(DEPRECATED) execute a rig function with 52 operands" },
|
|
{ "Execute_54_Operands.Comment", "// (DEPRECATED) execute a rig function with 53 operands\n" },
|
|
{ "Execute_54_Operands.Name", "ERigVMOpCode::Execute_54_Operands" },
|
|
{ "Execute_54_Operands.ToolTip", "(DEPRECATED) execute a rig function with 53 operands" },
|
|
{ "Execute_55_Operands.Comment", "// (DEPRECATED) execute a rig function with 54 operands\n" },
|
|
{ "Execute_55_Operands.Name", "ERigVMOpCode::Execute_55_Operands" },
|
|
{ "Execute_55_Operands.ToolTip", "(DEPRECATED) execute a rig function with 54 operands" },
|
|
{ "Execute_56_Operands.Comment", "// (DEPRECATED) execute a rig function with 55 operands\n" },
|
|
{ "Execute_56_Operands.Name", "ERigVMOpCode::Execute_56_Operands" },
|
|
{ "Execute_56_Operands.ToolTip", "(DEPRECATED) execute a rig function with 55 operands" },
|
|
{ "Execute_57_Operands.Comment", "// (DEPRECATED) execute a rig function with 56 operands\n" },
|
|
{ "Execute_57_Operands.Name", "ERigVMOpCode::Execute_57_Operands" },
|
|
{ "Execute_57_Operands.ToolTip", "(DEPRECATED) execute a rig function with 56 operands" },
|
|
{ "Execute_58_Operands.Comment", "// (DEPRECATED) execute a rig function with 57 operands\n" },
|
|
{ "Execute_58_Operands.Name", "ERigVMOpCode::Execute_58_Operands" },
|
|
{ "Execute_58_Operands.ToolTip", "(DEPRECATED) execute a rig function with 57 operands" },
|
|
{ "Execute_59_Operands.Comment", "// (DEPRECATED) execute a rig function with 58 operands\n" },
|
|
{ "Execute_59_Operands.Name", "ERigVMOpCode::Execute_59_Operands" },
|
|
{ "Execute_59_Operands.ToolTip", "(DEPRECATED) execute a rig function with 58 operands" },
|
|
{ "Execute_5_Operands.Comment", "// (DEPRECATED) execute a rig function with 4 operands\n" },
|
|
{ "Execute_5_Operands.Name", "ERigVMOpCode::Execute_5_Operands" },
|
|
{ "Execute_5_Operands.ToolTip", "(DEPRECATED) execute a rig function with 4 operands" },
|
|
{ "Execute_60_Operands.Comment", "// (DEPRECATED) execute a rig function with 59 operands\n" },
|
|
{ "Execute_60_Operands.Name", "ERigVMOpCode::Execute_60_Operands" },
|
|
{ "Execute_60_Operands.ToolTip", "(DEPRECATED) execute a rig function with 59 operands" },
|
|
{ "Execute_61_Operands.Comment", "// (DEPRECATED) execute a rig function with 60 operands\n" },
|
|
{ "Execute_61_Operands.Name", "ERigVMOpCode::Execute_61_Operands" },
|
|
{ "Execute_61_Operands.ToolTip", "(DEPRECATED) execute a rig function with 60 operands" },
|
|
{ "Execute_62_Operands.Comment", "// (DEPRECATED) execute a rig function with 61 operands\n" },
|
|
{ "Execute_62_Operands.Name", "ERigVMOpCode::Execute_62_Operands" },
|
|
{ "Execute_62_Operands.ToolTip", "(DEPRECATED) execute a rig function with 61 operands" },
|
|
{ "Execute_63_Operands.Comment", "// (DEPRECATED) execute a rig function with 62 operands\n" },
|
|
{ "Execute_63_Operands.Name", "ERigVMOpCode::Execute_63_Operands" },
|
|
{ "Execute_63_Operands.ToolTip", "(DEPRECATED) execute a rig function with 62 operands" },
|
|
{ "Execute_64_Operands.Comment", "// (DEPRECATED) execute a rig function with 63 operands\n" },
|
|
{ "Execute_64_Operands.Name", "ERigVMOpCode::Execute_64_Operands" },
|
|
{ "Execute_64_Operands.ToolTip", "(DEPRECATED) execute a rig function with 63 operands" },
|
|
{ "Execute_6_Operands.Comment", "// (DEPRECATED) execute a rig function with 5 operands\n" },
|
|
{ "Execute_6_Operands.Name", "ERigVMOpCode::Execute_6_Operands" },
|
|
{ "Execute_6_Operands.ToolTip", "(DEPRECATED) execute a rig function with 5 operands" },
|
|
{ "Execute_7_Operands.Comment", "// (DEPRECATED) execute a rig function with 6 operands\n" },
|
|
{ "Execute_7_Operands.Name", "ERigVMOpCode::Execute_7_Operands" },
|
|
{ "Execute_7_Operands.ToolTip", "(DEPRECATED) execute a rig function with 6 operands" },
|
|
{ "Execute_8_Operands.Comment", "// (DEPRECATED) execute a rig function with 7 operands\n" },
|
|
{ "Execute_8_Operands.Name", "ERigVMOpCode::Execute_8_Operands" },
|
|
{ "Execute_8_Operands.ToolTip", "(DEPRECATED) execute a rig function with 7 operands" },
|
|
{ "Execute_9_Operands.Comment", "// (DEPRECATED) execute a rig function with 8 operands\n" },
|
|
{ "Execute_9_Operands.Name", "ERigVMOpCode::Execute_9_Operands" },
|
|
{ "Execute_9_Operands.ToolTip", "(DEPRECATED) execute a rig function with 8 operands" },
|
|
{ "Exit.Comment", "// change the type of a register (deprecated)\n" },
|
|
{ "Exit.Name", "ERigVMOpCode::Exit" },
|
|
{ "Exit.ToolTip", "change the type of a register (deprecated)" },
|
|
{ "FirstArrayOpCode.Name", "ERigVMOpCode::FirstArrayOpCode" },
|
|
{ "Increment.Comment", "// copy the content of one register to another\n" },
|
|
{ "Increment.Name", "ERigVMOpCode::Increment" },
|
|
{ "Increment.ToolTip", "copy the content of one register to another" },
|
|
{ "Invalid.Comment", "// sets up a list of traits on executecontext\n" },
|
|
{ "Invalid.Name", "ERigVMOpCode::Invalid" },
|
|
{ "Invalid.ToolTip", "sets up a list of traits on executecontext" },
|
|
{ "InvokeEntry.Comment", "// (DEPRECATED) returns the reverse of the input array (unary op, in out array)\n" },
|
|
{ "InvokeEntry.Name", "ERigVMOpCode::InvokeEntry" },
|
|
{ "InvokeEntry.ToolTip", "(DEPRECATED) returns the reverse of the input array (unary op, in out array)" },
|
|
{ "JumpAbsolute.Comment", "// fill a bool register with the result of (A != B)\n" },
|
|
{ "JumpAbsolute.Name", "ERigVMOpCode::JumpAbsolute" },
|
|
{ "JumpAbsolute.ToolTip", "fill a bool register with the result of (A != B)" },
|
|
{ "JumpAbsoluteIf.Comment", "// jump backwards given a relative instruction index offset\n" },
|
|
{ "JumpAbsoluteIf.Name", "ERigVMOpCode::JumpAbsoluteIf" },
|
|
{ "JumpAbsoluteIf.ToolTip", "jump backwards given a relative instruction index offset" },
|
|
{ "JumpBackward.Comment", "// jump forwards given a relative instruction index offset\n" },
|
|
{ "JumpBackward.Name", "ERigVMOpCode::JumpBackward" },
|
|
{ "JumpBackward.ToolTip", "jump forwards given a relative instruction index offset" },
|
|
{ "JumpBackwardIf.Comment", "// jump forwards given a relative instruction index offset based on a condition register\n" },
|
|
{ "JumpBackwardIf.Name", "ERigVMOpCode::JumpBackwardIf" },
|
|
{ "JumpBackwardIf.ToolTip", "jump forwards given a relative instruction index offset based on a condition register" },
|
|
{ "JumpForward.Comment", "// jump to an absolute instruction index\n" },
|
|
{ "JumpForward.Name", "ERigVMOpCode::JumpForward" },
|
|
{ "JumpForward.ToolTip", "jump to an absolute instruction index" },
|
|
{ "JumpForwardIf.Comment", "// jump to an absolute instruction index based on a condition register\n" },
|
|
{ "JumpForwardIf.Name", "ERigVMOpCode::JumpForwardIf" },
|
|
{ "JumpForwardIf.ToolTip", "jump to an absolute instruction index based on a condition register" },
|
|
{ "JumpToBranch.Comment", "// invokes an entry from the entry list\n" },
|
|
{ "JumpToBranch.Name", "ERigVMOpCode::JumpToBranch" },
|
|
{ "JumpToBranch.ToolTip", "invokes an entry from the entry list" },
|
|
{ "LastArrayOpCode.Name", "ERigVMOpCode::LastArrayOpCode" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "NotEquals.Comment", "// fill a bool register with the result of (A == B)\n" },
|
|
{ "NotEquals.Name", "ERigVMOpCode::NotEquals" },
|
|
{ "NotEquals.ToolTip", "fill a bool register with the result of (A == B)" },
|
|
{ "RunInstructions.Comment", "// single execute op (formerly Execute_0_Operands to Execute_64_Operands)\n" },
|
|
{ "RunInstructions.Name", "ERigVMOpCode::RunInstructions" },
|
|
{ "RunInstructions.ToolTip", "single execute op (formerly Execute_0_Operands to Execute_64_Operands)" },
|
|
{ "SetupTraits.Comment", "// runs a set of instructions lazily\n" },
|
|
{ "SetupTraits.Name", "ERigVMOpCode::SetupTraits" },
|
|
{ "SetupTraits.ToolTip", "runs a set of instructions lazily" },
|
|
{ "ToolTip", "The code for a single operation within the RigVM" },
|
|
{ "Zero.Comment", "// (DEPRECATED) execute a rig function with 64 operands\n" },
|
|
{ "Zero.Name", "ERigVMOpCode::Zero" },
|
|
{ "Zero.ToolTip", "(DEPRECATED) execute a rig function with 64 operands" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
|
|
{ "ERigVMOpCode::Execute_0_Operands", (int64)ERigVMOpCode::Execute_0_Operands },
|
|
{ "ERigVMOpCode::Execute_1_Operands", (int64)ERigVMOpCode::Execute_1_Operands },
|
|
{ "ERigVMOpCode::Execute_2_Operands", (int64)ERigVMOpCode::Execute_2_Operands },
|
|
{ "ERigVMOpCode::Execute_3_Operands", (int64)ERigVMOpCode::Execute_3_Operands },
|
|
{ "ERigVMOpCode::Execute_4_Operands", (int64)ERigVMOpCode::Execute_4_Operands },
|
|
{ "ERigVMOpCode::Execute_5_Operands", (int64)ERigVMOpCode::Execute_5_Operands },
|
|
{ "ERigVMOpCode::Execute_6_Operands", (int64)ERigVMOpCode::Execute_6_Operands },
|
|
{ "ERigVMOpCode::Execute_7_Operands", (int64)ERigVMOpCode::Execute_7_Operands },
|
|
{ "ERigVMOpCode::Execute_8_Operands", (int64)ERigVMOpCode::Execute_8_Operands },
|
|
{ "ERigVMOpCode::Execute_9_Operands", (int64)ERigVMOpCode::Execute_9_Operands },
|
|
{ "ERigVMOpCode::Execute_10_Operands", (int64)ERigVMOpCode::Execute_10_Operands },
|
|
{ "ERigVMOpCode::Execute_11_Operands", (int64)ERigVMOpCode::Execute_11_Operands },
|
|
{ "ERigVMOpCode::Execute_12_Operands", (int64)ERigVMOpCode::Execute_12_Operands },
|
|
{ "ERigVMOpCode::Execute_13_Operands", (int64)ERigVMOpCode::Execute_13_Operands },
|
|
{ "ERigVMOpCode::Execute_14_Operands", (int64)ERigVMOpCode::Execute_14_Operands },
|
|
{ "ERigVMOpCode::Execute_15_Operands", (int64)ERigVMOpCode::Execute_15_Operands },
|
|
{ "ERigVMOpCode::Execute_16_Operands", (int64)ERigVMOpCode::Execute_16_Operands },
|
|
{ "ERigVMOpCode::Execute_17_Operands", (int64)ERigVMOpCode::Execute_17_Operands },
|
|
{ "ERigVMOpCode::Execute_18_Operands", (int64)ERigVMOpCode::Execute_18_Operands },
|
|
{ "ERigVMOpCode::Execute_19_Operands", (int64)ERigVMOpCode::Execute_19_Operands },
|
|
{ "ERigVMOpCode::Execute_20_Operands", (int64)ERigVMOpCode::Execute_20_Operands },
|
|
{ "ERigVMOpCode::Execute_21_Operands", (int64)ERigVMOpCode::Execute_21_Operands },
|
|
{ "ERigVMOpCode::Execute_22_Operands", (int64)ERigVMOpCode::Execute_22_Operands },
|
|
{ "ERigVMOpCode::Execute_23_Operands", (int64)ERigVMOpCode::Execute_23_Operands },
|
|
{ "ERigVMOpCode::Execute_24_Operands", (int64)ERigVMOpCode::Execute_24_Operands },
|
|
{ "ERigVMOpCode::Execute_25_Operands", (int64)ERigVMOpCode::Execute_25_Operands },
|
|
{ "ERigVMOpCode::Execute_26_Operands", (int64)ERigVMOpCode::Execute_26_Operands },
|
|
{ "ERigVMOpCode::Execute_27_Operands", (int64)ERigVMOpCode::Execute_27_Operands },
|
|
{ "ERigVMOpCode::Execute_28_Operands", (int64)ERigVMOpCode::Execute_28_Operands },
|
|
{ "ERigVMOpCode::Execute_29_Operands", (int64)ERigVMOpCode::Execute_29_Operands },
|
|
{ "ERigVMOpCode::Execute_30_Operands", (int64)ERigVMOpCode::Execute_30_Operands },
|
|
{ "ERigVMOpCode::Execute_31_Operands", (int64)ERigVMOpCode::Execute_31_Operands },
|
|
{ "ERigVMOpCode::Execute_32_Operands", (int64)ERigVMOpCode::Execute_32_Operands },
|
|
{ "ERigVMOpCode::Execute_33_Operands", (int64)ERigVMOpCode::Execute_33_Operands },
|
|
{ "ERigVMOpCode::Execute_34_Operands", (int64)ERigVMOpCode::Execute_34_Operands },
|
|
{ "ERigVMOpCode::Execute_35_Operands", (int64)ERigVMOpCode::Execute_35_Operands },
|
|
{ "ERigVMOpCode::Execute_36_Operands", (int64)ERigVMOpCode::Execute_36_Operands },
|
|
{ "ERigVMOpCode::Execute_37_Operands", (int64)ERigVMOpCode::Execute_37_Operands },
|
|
{ "ERigVMOpCode::Execute_38_Operands", (int64)ERigVMOpCode::Execute_38_Operands },
|
|
{ "ERigVMOpCode::Execute_39_Operands", (int64)ERigVMOpCode::Execute_39_Operands },
|
|
{ "ERigVMOpCode::Execute_40_Operands", (int64)ERigVMOpCode::Execute_40_Operands },
|
|
{ "ERigVMOpCode::Execute_41_Operands", (int64)ERigVMOpCode::Execute_41_Operands },
|
|
{ "ERigVMOpCode::Execute_42_Operands", (int64)ERigVMOpCode::Execute_42_Operands },
|
|
{ "ERigVMOpCode::Execute_43_Operands", (int64)ERigVMOpCode::Execute_43_Operands },
|
|
{ "ERigVMOpCode::Execute_44_Operands", (int64)ERigVMOpCode::Execute_44_Operands },
|
|
{ "ERigVMOpCode::Execute_45_Operands", (int64)ERigVMOpCode::Execute_45_Operands },
|
|
{ "ERigVMOpCode::Execute_46_Operands", (int64)ERigVMOpCode::Execute_46_Operands },
|
|
{ "ERigVMOpCode::Execute_47_Operands", (int64)ERigVMOpCode::Execute_47_Operands },
|
|
{ "ERigVMOpCode::Execute_48_Operands", (int64)ERigVMOpCode::Execute_48_Operands },
|
|
{ "ERigVMOpCode::Execute_49_Operands", (int64)ERigVMOpCode::Execute_49_Operands },
|
|
{ "ERigVMOpCode::Execute_50_Operands", (int64)ERigVMOpCode::Execute_50_Operands },
|
|
{ "ERigVMOpCode::Execute_51_Operands", (int64)ERigVMOpCode::Execute_51_Operands },
|
|
{ "ERigVMOpCode::Execute_52_Operands", (int64)ERigVMOpCode::Execute_52_Operands },
|
|
{ "ERigVMOpCode::Execute_53_Operands", (int64)ERigVMOpCode::Execute_53_Operands },
|
|
{ "ERigVMOpCode::Execute_54_Operands", (int64)ERigVMOpCode::Execute_54_Operands },
|
|
{ "ERigVMOpCode::Execute_55_Operands", (int64)ERigVMOpCode::Execute_55_Operands },
|
|
{ "ERigVMOpCode::Execute_56_Operands", (int64)ERigVMOpCode::Execute_56_Operands },
|
|
{ "ERigVMOpCode::Execute_57_Operands", (int64)ERigVMOpCode::Execute_57_Operands },
|
|
{ "ERigVMOpCode::Execute_58_Operands", (int64)ERigVMOpCode::Execute_58_Operands },
|
|
{ "ERigVMOpCode::Execute_59_Operands", (int64)ERigVMOpCode::Execute_59_Operands },
|
|
{ "ERigVMOpCode::Execute_60_Operands", (int64)ERigVMOpCode::Execute_60_Operands },
|
|
{ "ERigVMOpCode::Execute_61_Operands", (int64)ERigVMOpCode::Execute_61_Operands },
|
|
{ "ERigVMOpCode::Execute_62_Operands", (int64)ERigVMOpCode::Execute_62_Operands },
|
|
{ "ERigVMOpCode::Execute_63_Operands", (int64)ERigVMOpCode::Execute_63_Operands },
|
|
{ "ERigVMOpCode::Execute_64_Operands", (int64)ERigVMOpCode::Execute_64_Operands },
|
|
{ "ERigVMOpCode::Zero", (int64)ERigVMOpCode::Zero },
|
|
{ "ERigVMOpCode::BoolFalse", (int64)ERigVMOpCode::BoolFalse },
|
|
{ "ERigVMOpCode::BoolTrue", (int64)ERigVMOpCode::BoolTrue },
|
|
{ "ERigVMOpCode::Copy", (int64)ERigVMOpCode::Copy },
|
|
{ "ERigVMOpCode::Increment", (int64)ERigVMOpCode::Increment },
|
|
{ "ERigVMOpCode::Decrement", (int64)ERigVMOpCode::Decrement },
|
|
{ "ERigVMOpCode::Equals", (int64)ERigVMOpCode::Equals },
|
|
{ "ERigVMOpCode::NotEquals", (int64)ERigVMOpCode::NotEquals },
|
|
{ "ERigVMOpCode::JumpAbsolute", (int64)ERigVMOpCode::JumpAbsolute },
|
|
{ "ERigVMOpCode::JumpForward", (int64)ERigVMOpCode::JumpForward },
|
|
{ "ERigVMOpCode::JumpBackward", (int64)ERigVMOpCode::JumpBackward },
|
|
{ "ERigVMOpCode::JumpAbsoluteIf", (int64)ERigVMOpCode::JumpAbsoluteIf },
|
|
{ "ERigVMOpCode::JumpForwardIf", (int64)ERigVMOpCode::JumpForwardIf },
|
|
{ "ERigVMOpCode::JumpBackwardIf", (int64)ERigVMOpCode::JumpBackwardIf },
|
|
{ "ERigVMOpCode::ChangeType", (int64)ERigVMOpCode::ChangeType },
|
|
{ "ERigVMOpCode::Exit", (int64)ERigVMOpCode::Exit },
|
|
{ "ERigVMOpCode::BeginBlock", (int64)ERigVMOpCode::BeginBlock },
|
|
{ "ERigVMOpCode::EndBlock", (int64)ERigVMOpCode::EndBlock },
|
|
{ "ERigVMOpCode::ArrayReset", (int64)ERigVMOpCode::ArrayReset },
|
|
{ "ERigVMOpCode::ArrayGetNum", (int64)ERigVMOpCode::ArrayGetNum },
|
|
{ "ERigVMOpCode::ArraySetNum", (int64)ERigVMOpCode::ArraySetNum },
|
|
{ "ERigVMOpCode::ArrayGetAtIndex", (int64)ERigVMOpCode::ArrayGetAtIndex },
|
|
{ "ERigVMOpCode::ArraySetAtIndex", (int64)ERigVMOpCode::ArraySetAtIndex },
|
|
{ "ERigVMOpCode::ArrayAdd", (int64)ERigVMOpCode::ArrayAdd },
|
|
{ "ERigVMOpCode::ArrayInsert", (int64)ERigVMOpCode::ArrayInsert },
|
|
{ "ERigVMOpCode::ArrayRemove", (int64)ERigVMOpCode::ArrayRemove },
|
|
{ "ERigVMOpCode::ArrayFind", (int64)ERigVMOpCode::ArrayFind },
|
|
{ "ERigVMOpCode::ArrayAppend", (int64)ERigVMOpCode::ArrayAppend },
|
|
{ "ERigVMOpCode::ArrayClone", (int64)ERigVMOpCode::ArrayClone },
|
|
{ "ERigVMOpCode::ArrayIterator", (int64)ERigVMOpCode::ArrayIterator },
|
|
{ "ERigVMOpCode::ArrayUnion", (int64)ERigVMOpCode::ArrayUnion },
|
|
{ "ERigVMOpCode::ArrayDifference", (int64)ERigVMOpCode::ArrayDifference },
|
|
{ "ERigVMOpCode::ArrayIntersection", (int64)ERigVMOpCode::ArrayIntersection },
|
|
{ "ERigVMOpCode::ArrayReverse", (int64)ERigVMOpCode::ArrayReverse },
|
|
{ "ERigVMOpCode::InvokeEntry", (int64)ERigVMOpCode::InvokeEntry },
|
|
{ "ERigVMOpCode::JumpToBranch", (int64)ERigVMOpCode::JumpToBranch },
|
|
{ "ERigVMOpCode::Execute", (int64)ERigVMOpCode::Execute },
|
|
{ "ERigVMOpCode::RunInstructions", (int64)ERigVMOpCode::RunInstructions },
|
|
{ "ERigVMOpCode::SetupTraits", (int64)ERigVMOpCode::SetupTraits },
|
|
{ "ERigVMOpCode::Invalid", (int64)ERigVMOpCode::Invalid },
|
|
{ "ERigVMOpCode::FirstArrayOpCode", (int64)ERigVMOpCode::FirstArrayOpCode },
|
|
{ "ERigVMOpCode::LastArrayOpCode", (int64)ERigVMOpCode::LastArrayOpCode },
|
|
};
|
|
static const UECodeGen_Private::FEnumParams EnumParams;
|
|
}; // struct Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics
|
|
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::EnumParams = {
|
|
(UObject*(*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
"ERigVMOpCode",
|
|
"ERigVMOpCode",
|
|
Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::Enumerators,
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
UE_ARRAY_COUNT(Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::Enumerators),
|
|
EEnumFlags::None,
|
|
(uint8)UEnum::ECppForm::EnumClass,
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::Enum_MetaDataParams), Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::Enum_MetaDataParams)
|
|
};
|
|
UEnum* Z_Construct_UEnum_RigVM_ERigVMOpCode()
|
|
{
|
|
if (!Z_Registration_Info_UEnum_ERigVMOpCode.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ERigVMOpCode.InnerSingleton, Z_Construct_UEnum_RigVM_ERigVMOpCode_Statics::EnumParams);
|
|
}
|
|
return Z_Registration_Info_UEnum_ERigVMOpCode.InnerSingleton;
|
|
}
|
|
// ********** End Enum ERigVMOpCode ****************************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMBaseOp ******************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMBaseOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMBaseOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMBaseOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// Base class for all VM operations\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "Base class for all VM operations" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMBaseOp constinit property declarations **********************
|
|
// ********** End ScriptStruct FRigVMBaseOp constinit property declarations ************************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMBaseOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMBaseOp_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMBaseOp;
|
|
class UScriptStruct* FRigVMBaseOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMBaseOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMBaseOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMBaseOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMBaseOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMBaseOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMBaseOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMBaseOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMBaseOp),
|
|
alignof(FRigVMBaseOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMBaseOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMBaseOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMBaseOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMBaseOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMBaseOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMBaseOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMBaseOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMBaseOp ********************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMExecuteOp ***************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMExecuteOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMExecuteOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// execute a function\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "execute a function" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMExecuteOp constinit property declarations *******************
|
|
// ********** End ScriptStruct FRigVMExecuteOp constinit property declarations *********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMExecuteOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMExecuteOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMExecuteOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMExecuteOp;
|
|
class UScriptStruct* FRigVMExecuteOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMExecuteOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMExecuteOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMExecuteOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMExecuteOp),
|
|
alignof(FRigVMExecuteOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMExecuteOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMExecuteOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMExecuteOp *****************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMUnaryOp *****************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMUnaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMUnaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for zero, false, true, increment, decrement\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for zero, false, true, increment, decrement" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMUnaryOp constinit property declarations *********************
|
|
// ********** End ScriptStruct FRigVMUnaryOp constinit property declarations ***********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMUnaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMUnaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMUnaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMUnaryOp;
|
|
class UScriptStruct* FRigVMUnaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMUnaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMUnaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMUnaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMUnaryOp),
|
|
alignof(FRigVMUnaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMUnaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMUnaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMUnaryOp *******************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMBinaryOp ****************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMBinaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMBinaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for beginblock and array reset\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for beginblock and array reset" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMBinaryOp constinit property declarations ********************
|
|
// ********** End ScriptStruct FRigVMBinaryOp constinit property declarations **********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMBinaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMBinaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMBinaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMBinaryOp;
|
|
class UScriptStruct* FRigVMBinaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMBinaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMBinaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMBinaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMBinaryOp),
|
|
alignof(FRigVMBinaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMBinaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMBinaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMBinaryOp ******************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMTernaryOp ***************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMTernaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMTernaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for some array operations\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for some array operations" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMTernaryOp constinit property declarations *******************
|
|
// ********** End ScriptStruct FRigVMTernaryOp constinit property declarations *********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMTernaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMTernaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMTernaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMTernaryOp;
|
|
class UScriptStruct* FRigVMTernaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMTernaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMTernaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMTernaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMTernaryOp),
|
|
alignof(FRigVMTernaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMTernaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMTernaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMTernaryOp *****************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMQuaternaryOp ************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMQuaternaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMQuaternaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for some array operations\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for some array operations" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMQuaternaryOp constinit property declarations ****************
|
|
// ********** End ScriptStruct FRigVMQuaternaryOp constinit property declarations ******************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMQuaternaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMQuaternaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMQuaternaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp;
|
|
class UScriptStruct* FRigVMQuaternaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMQuaternaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMQuaternaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMQuaternaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMQuaternaryOp),
|
|
alignof(FRigVMQuaternaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMQuaternaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMQuaternaryOp **************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMQuinaryOp ***************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMQuinaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMQuinaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for some array operations\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for some array operations" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMQuinaryOp constinit property declarations *******************
|
|
// ********** End ScriptStruct FRigVMQuinaryOp constinit property declarations *********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMQuinaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMQuinaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMQuinaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp;
|
|
class UScriptStruct* FRigVMQuinaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMQuinaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMQuinaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMQuinaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMQuinaryOp),
|
|
alignof(FRigVMQuinaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMQuinaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMQuinaryOp *****************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMSenaryOp ****************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMSenaryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMSenaryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// operator used for some array operations\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "operator used for some array operations" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMSenaryOp constinit property declarations ********************
|
|
// ********** End ScriptStruct FRigVMSenaryOp constinit property declarations **********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMSenaryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMSenaryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMSenaryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMSenaryOp;
|
|
class UScriptStruct* FRigVMSenaryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMSenaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMSenaryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMSenaryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMSenaryOp),
|
|
alignof(FRigVMSenaryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMSenaryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMSenaryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMSenaryOp ******************************************************
|
|
|
|
// ********** Begin Enum ERigVMCopyType ************************************************************
|
|
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ERigVMCopyType;
|
|
static UEnum* ERigVMCopyType_StaticEnum()
|
|
{
|
|
if (!Z_Registration_Info_UEnum_ERigVMCopyType.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UEnum_ERigVMCopyType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_RigVM_ERigVMCopyType, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("ERigVMCopyType"));
|
|
}
|
|
return Z_Registration_Info_UEnum_ERigVMCopyType.OuterSingleton;
|
|
}
|
|
template<> RIGVM_NON_ATTRIBUTED_API UEnum* StaticEnum<ERigVMCopyType>()
|
|
{
|
|
return ERigVMCopyType_StaticEnum();
|
|
}
|
|
struct Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics
|
|
{
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
|
|
{ "Comment", "// The kind of copy operation to perform\n" },
|
|
{ "Default.Name", "ERigVMCopyType::Default" },
|
|
{ "DoubleToFloat.Name", "ERigVMCopyType::DoubleToFloat" },
|
|
{ "FloatToDouble.Name", "ERigVMCopyType::FloatToDouble" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "The kind of copy operation to perform" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
|
|
{ "ERigVMCopyType::Default", (int64)ERigVMCopyType::Default },
|
|
{ "ERigVMCopyType::FloatToDouble", (int64)ERigVMCopyType::FloatToDouble },
|
|
{ "ERigVMCopyType::DoubleToFloat", (int64)ERigVMCopyType::DoubleToFloat },
|
|
};
|
|
static const UECodeGen_Private::FEnumParams EnumParams;
|
|
}; // struct Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics
|
|
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::EnumParams = {
|
|
(UObject*(*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
"ERigVMCopyType",
|
|
"ERigVMCopyType",
|
|
Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::Enumerators,
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
UE_ARRAY_COUNT(Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::Enumerators),
|
|
EEnumFlags::None,
|
|
(uint8)UEnum::ECppForm::EnumClass,
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::Enum_MetaDataParams)
|
|
};
|
|
UEnum* Z_Construct_UEnum_RigVM_ERigVMCopyType()
|
|
{
|
|
if (!Z_Registration_Info_UEnum_ERigVMCopyType.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ERigVMCopyType.InnerSingleton, Z_Construct_UEnum_RigVM_ERigVMCopyType_Statics::EnumParams);
|
|
}
|
|
return Z_Registration_Info_UEnum_ERigVMCopyType.InnerSingleton;
|
|
}
|
|
// ********** End Enum ERigVMCopyType **************************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMCopyOp ******************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMCopyOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMCopyOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMCopyOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// copy the content of one register to another\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "copy the content of one register to another" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMCopyOp constinit property declarations **********************
|
|
// ********** End ScriptStruct FRigVMCopyOp constinit property declarations ************************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMCopyOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMCopyOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMCopyOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMCopyOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMCopyOp;
|
|
class UScriptStruct* FRigVMCopyOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMCopyOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMCopyOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMCopyOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMCopyOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMCopyOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMCopyOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMCopyOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMCopyOp),
|
|
alignof(FRigVMCopyOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMCopyOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMCopyOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMCopyOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMCopyOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMCopyOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMCopyOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMCopyOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMCopyOp ********************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMComparisonOp ************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMComparisonOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMComparisonOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// used for equals and not equals comparisons\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "used for equals and not equals comparisons" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMComparisonOp constinit property declarations ****************
|
|
// ********** End ScriptStruct FRigVMComparisonOp constinit property declarations ******************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMComparisonOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMComparisonOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMComparisonOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMComparisonOp;
|
|
class UScriptStruct* FRigVMComparisonOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMComparisonOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMComparisonOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMComparisonOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMComparisonOp),
|
|
alignof(FRigVMComparisonOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMComparisonOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMComparisonOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMComparisonOp **************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpOp ******************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMJumpOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMJumpOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMJumpOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// jump to a new instruction index.\n// the instruction can be absolute, relative forward or relative backward\n// based on the opcode \n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "jump to a new instruction index.\nthe instruction can be absolute, relative forward or relative backward\nbased on the opcode" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpOp constinit property declarations **********************
|
|
// ********** End ScriptStruct FRigVMJumpOp constinit property declarations ************************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMJumpOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMJumpOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMJumpOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMJumpOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMJumpOp;
|
|
class UScriptStruct* FRigVMJumpOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMJumpOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMJumpOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMJumpOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMJumpOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMJumpOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMJumpOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMJumpOp),
|
|
alignof(FRigVMJumpOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMJumpOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMJumpOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMJumpOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMJumpOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMJumpOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMJumpOp ********************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpIfOp ****************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMJumpIfOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMJumpIfOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// jump to a new instruction index based on a condition.\n// the instruction can be absolute, relative forward or relative backward\n// based on the opcode \n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "jump to a new instruction index based on a condition.\nthe instruction can be absolute, relative forward or relative backward\nbased on the opcode" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpIfOp constinit property declarations ********************
|
|
// ********** End ScriptStruct FRigVMJumpIfOp constinit property declarations **********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMJumpIfOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMJumpIfOp>() == std::is_polymorphic<FRigVMUnaryOp>(), "USTRUCT FRigVMJumpIfOp cannot be polymorphic unless super FRigVMUnaryOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp;
|
|
class UScriptStruct* FRigVMJumpIfOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMJumpIfOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMJumpIfOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMUnaryOp,
|
|
&NewStructOps,
|
|
"RigVMJumpIfOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMJumpIfOp),
|
|
alignof(FRigVMJumpIfOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpIfOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMJumpIfOp ******************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMChangeTypeOp ************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMChangeTypeOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMChangeTypeOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// change the type of a register\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "change the type of a register" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMChangeTypeOp constinit property declarations ****************
|
|
// ********** End ScriptStruct FRigVMChangeTypeOp constinit property declarations ******************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMChangeTypeOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMChangeTypeOp>() == std::is_polymorphic<FRigVMUnaryOp>(), "USTRUCT FRigVMChangeTypeOp cannot be polymorphic unless super FRigVMUnaryOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp;
|
|
class UScriptStruct* FRigVMChangeTypeOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMChangeTypeOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMChangeTypeOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMUnaryOp,
|
|
&NewStructOps,
|
|
"RigVMChangeTypeOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMChangeTypeOp),
|
|
alignof(FRigVMChangeTypeOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMChangeTypeOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMChangeTypeOp **************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMInvokeEntryOp ***********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMInvokeEntryOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMInvokeEntryOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// invoke another entry\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "invoke another entry" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMInvokeEntryOp constinit property declarations ***************
|
|
// ********** End ScriptStruct FRigVMInvokeEntryOp constinit property declarations *****************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMInvokeEntryOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMInvokeEntryOp>() == std::is_polymorphic<FRigVMBaseOp>(), "USTRUCT FRigVMInvokeEntryOp cannot be polymorphic unless super FRigVMBaseOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp;
|
|
class UScriptStruct* FRigVMInvokeEntryOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMInvokeEntryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMInvokeEntryOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMBaseOp,
|
|
&NewStructOps,
|
|
"RigVMInvokeEntryOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMInvokeEntryOp),
|
|
alignof(FRigVMInvokeEntryOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMInvokeEntryOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMInvokeEntryOp *************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpToBranchOp **********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMJumpToBranchOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMJumpToBranchOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// jump into a branch based on a name argument\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "jump into a branch based on a name argument" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMJumpToBranchOp constinit property declarations **************
|
|
// ********** End ScriptStruct FRigVMJumpToBranchOp constinit property declarations ****************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMJumpToBranchOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMJumpToBranchOp>() == std::is_polymorphic<FRigVMUnaryOp>(), "USTRUCT FRigVMJumpToBranchOp cannot be polymorphic unless super FRigVMUnaryOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp;
|
|
class UScriptStruct* FRigVMJumpToBranchOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMJumpToBranchOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMJumpToBranchOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMUnaryOp,
|
|
&NewStructOps,
|
|
"RigVMJumpToBranchOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMJumpToBranchOp),
|
|
alignof(FRigVMJumpToBranchOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMJumpToBranchOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMJumpToBranchOp ************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMRunInstructionsOp *******************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMRunInstructionsOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMRunInstructionsOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// runs a set of instructions lazily\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "runs a set of instructions lazily" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMRunInstructionsOp constinit property declarations ***********
|
|
// ********** End ScriptStruct FRigVMRunInstructionsOp constinit property declarations *************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMRunInstructionsOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMRunInstructionsOp>() == std::is_polymorphic<FRigVMUnaryOp>(), "USTRUCT FRigVMRunInstructionsOp cannot be polymorphic unless super FRigVMUnaryOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp;
|
|
class UScriptStruct* FRigVMRunInstructionsOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMRunInstructionsOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMRunInstructionsOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMUnaryOp,
|
|
&NewStructOps,
|
|
"RigVMRunInstructionsOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMRunInstructionsOp),
|
|
alignof(FRigVMRunInstructionsOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMRunInstructionsOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMRunInstructionsOp *********************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMSetupTraitsOp ***********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMSetupTraitsOp); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMSetupTraitsOp); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "// sets up a list of traits in the execute context\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "sets up a list of traits in the execute context" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMSetupTraitsOp constinit property declarations ***************
|
|
// ********** End ScriptStruct FRigVMSetupTraitsOp constinit property declarations *****************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMSetupTraitsOp>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics
|
|
static_assert(std::is_polymorphic<FRigVMSetupTraitsOp>() == std::is_polymorphic<FRigVMUnaryOp>(), "USTRUCT FRigVMSetupTraitsOp cannot be polymorphic unless super FRigVMUnaryOp is polymorphic");
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp;
|
|
class UScriptStruct* FRigVMSetupTraitsOp::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMSetupTraitsOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMSetupTraitsOp"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.OuterSingleton;
|
|
}
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
Z_Construct_UScriptStruct_FRigVMUnaryOp,
|
|
&NewStructOps,
|
|
"RigVMSetupTraitsOp",
|
|
nullptr,
|
|
0,
|
|
sizeof(FRigVMSetupTraitsOp),
|
|
alignof(FRigVMSetupTraitsOp),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMSetupTraitsOp()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMSetupTraitsOp *************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstruction *************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMInstruction_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMInstruction); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMInstruction); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "/**\n * The FRigVMInstruction represents\n * a single instruction within the VM.\n */" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "The FRigVMInstruction represents\na single instruction within the VM." },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Index_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ByteCodeIndex_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_OpCode_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_OperandAlignment_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstruction constinit property declarations *****************
|
|
static const UECodeGen_Private::FIntPropertyParams NewProp_Index;
|
|
static const UECodeGen_Private::FIntPropertyParams NewProp_ByteCodeIndex;
|
|
static const UECodeGen_Private::FBytePropertyParams NewProp_OpCode_Underlying;
|
|
static const UECodeGen_Private::FEnumPropertyParams NewProp_OpCode;
|
|
static const UECodeGen_Private::FBytePropertyParams NewProp_OperandAlignment;
|
|
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
|
|
// ********** End ScriptStruct FRigVMInstruction constinit property declarations *******************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMInstruction>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMInstruction_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMInstruction;
|
|
class UScriptStruct* FRigVMInstruction::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInstruction.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMInstruction.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMInstruction, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMInstruction"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMInstruction.OuterSingleton;
|
|
}
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstruction Property Definitions ****************************
|
|
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_Index = { "Index", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMInstruction, Index), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Index_MetaData), NewProp_Index_MetaData) };
|
|
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_ByteCodeIndex = { "ByteCodeIndex", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMInstruction, ByteCodeIndex), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ByteCodeIndex_MetaData), NewProp_ByteCodeIndex_MetaData) };
|
|
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OpCode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
|
|
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OpCode = { "OpCode", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMInstruction, OpCode), Z_Construct_UEnum_RigVM_ERigVMOpCode, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_OpCode_MetaData), NewProp_OpCode_MetaData) }; // 831061046
|
|
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OperandAlignment = { "OperandAlignment", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMInstruction, OperandAlignment), nullptr, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_OperandAlignment_MetaData), NewProp_OperandAlignment_MetaData) };
|
|
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMInstruction_Statics::PropPointers[] = {
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_Index,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_ByteCodeIndex,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OpCode_Underlying,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OpCode,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewProp_OperandAlignment,
|
|
};
|
|
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstruction_Statics::PropPointers) < 2048);
|
|
// ********** End ScriptStruct FRigVMInstruction Property Definitions ******************************
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMInstruction_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMInstruction",
|
|
Z_Construct_UScriptStruct_FRigVMInstruction_Statics::PropPointers,
|
|
UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstruction_Statics::PropPointers),
|
|
sizeof(FRigVMInstruction),
|
|
alignof(FRigVMInstruction),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstruction_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMInstruction_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMInstruction()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInstruction.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMInstruction.InnerSingleton, Z_Construct_UScriptStruct_FRigVMInstruction_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMInstruction.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMInstruction ***************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstructionArray ********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMInstructionArray); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMInstructionArray); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "/**\n * The FRigVMInstructionArray represents all current instructions\n * within a RigVM and can be used to iterate over all operators and retrieve\n * each instruction's data.\n */" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "The FRigVMInstructionArray represents all current instructions\nwithin a RigVM and can be used to iterate over all operators and retrieve\neach instruction's data." },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Instructions_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstructionArray constinit property declarations ************
|
|
static const UECodeGen_Private::FStructPropertyParams NewProp_Instructions_Inner;
|
|
static const UECodeGen_Private::FArrayPropertyParams NewProp_Instructions;
|
|
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
|
|
// ********** End ScriptStruct FRigVMInstructionArray constinit property declarations **************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMInstructionArray>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMInstructionArray;
|
|
class UScriptStruct* FRigVMInstructionArray::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMInstructionArray, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMInstructionArray"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.OuterSingleton;
|
|
}
|
|
|
|
// ********** Begin ScriptStruct FRigVMInstructionArray Property Definitions ***********************
|
|
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::NewProp_Instructions_Inner = { "Instructions", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UScriptStruct_FRigVMInstruction, METADATA_PARAMS(0, nullptr) }; // 1246216586
|
|
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::NewProp_Instructions = { "Instructions", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMInstructionArray, Instructions), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Instructions_MetaData), NewProp_Instructions_MetaData) }; // 1246216586
|
|
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::PropPointers[] = {
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::NewProp_Instructions_Inner,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::NewProp_Instructions,
|
|
};
|
|
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::PropPointers) < 2048);
|
|
// ********** End ScriptStruct FRigVMInstructionArray Property Definitions *************************
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMInstructionArray",
|
|
Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::PropPointers,
|
|
UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::PropPointers),
|
|
sizeof(FRigVMInstructionArray),
|
|
alignof(FRigVMInstructionArray),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMInstructionArray()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.InnerSingleton, Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMInstructionArray.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMInstructionArray **********************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCodeEntry ***********************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMByteCodeEntry); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMByteCodeEntry); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Name_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_InstructionIndex_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCodeEntry constinit property declarations ***************
|
|
static const UECodeGen_Private::FNamePropertyParams NewProp_Name;
|
|
static const UECodeGen_Private::FIntPropertyParams NewProp_InstructionIndex;
|
|
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
|
|
// ********** End ScriptStruct FRigVMByteCodeEntry constinit property declarations *****************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMByteCodeEntry>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry;
|
|
class UScriptStruct* FRigVMByteCodeEntry::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMByteCodeEntry, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMByteCodeEntry"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.OuterSingleton;
|
|
}
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCodeEntry Property Definitions **************************
|
|
const UECodeGen_Private::FNamePropertyParams Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::NewProp_Name = { "Name", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCodeEntry, Name), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Name_MetaData), NewProp_Name_MetaData) };
|
|
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::NewProp_InstructionIndex = { "InstructionIndex", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCodeEntry, InstructionIndex), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_InstructionIndex_MetaData), NewProp_InstructionIndex_MetaData) };
|
|
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::PropPointers[] = {
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::NewProp_Name,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::NewProp_InstructionIndex,
|
|
};
|
|
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::PropPointers) < 2048);
|
|
// ********** End ScriptStruct FRigVMByteCodeEntry Property Definitions ****************************
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMByteCodeEntry",
|
|
Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::PropPointers,
|
|
UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::PropPointers),
|
|
sizeof(FRigVMByteCodeEntry),
|
|
alignof(FRigVMByteCodeEntry),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMByteCodeEntry()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.InnerSingleton, Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMByteCodeEntry *************************************************
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCode ****************************************************
|
|
struct Z_Construct_UScriptStruct_FRigVMByteCode_Statics
|
|
{
|
|
static inline consteval int32 GetStructSize() { return sizeof(FRigVMByteCode); }
|
|
static inline consteval int16 GetStructAlignment() { return alignof(FRigVMByteCode); }
|
|
#if WITH_METADATA
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
|
|
{ "Comment", "/**\n * The FRigVMByteCode is a container to store a list of instructions with\n * their corresponding data. The byte code is then used within a VM to \n * execute. To iterate over the instructions within the byte code you can \n * use GetInstructions() to retrieve a FRigVMInstructionArray.\n */" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "The FRigVMByteCode is a container to store a list of instructions with\ntheir corresponding data. The byte code is then used within a VM to\nexecute. To iterate over the instructions within the byte code you can\nuse GetInstructions() to retrieve a FRigVMInstructionArray." },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ByteCode_MetaData[] = {
|
|
{ "Comment", "// memory for all instructions\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "memory for all instructions" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_NumInstructions_MetaData[] = {
|
|
{ "Comment", "// number of instructions stored here\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "number of instructions stored here" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Entries_MetaData[] = {
|
|
{ "Comment", "// a look up table from entry name to instruction index\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "a look up table from entry name to instruction index" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BranchInfos_MetaData[] = {
|
|
{ "Comment", "// a list of all lazily evaluation branches\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "a list of all lazily evaluation branches" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PredicateBranches_MetaData[] = {
|
|
{ "Comment", "// a list of all predicate branches\n" },
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
{ "ToolTip", "a list of all predicate branches" },
|
|
};
|
|
static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PublicContextAssetPath_MetaData[] = {
|
|
{ "ModuleRelativePath", "Public/RigVMCore/RigVMByteCode.h" },
|
|
};
|
|
#endif // WITH_METADATA
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCode constinit property declarations ********************
|
|
static const UECodeGen_Private::FBytePropertyParams NewProp_ByteCode_Inner;
|
|
static const UECodeGen_Private::FArrayPropertyParams NewProp_ByteCode;
|
|
static const UECodeGen_Private::FIntPropertyParams NewProp_NumInstructions;
|
|
static const UECodeGen_Private::FStructPropertyParams NewProp_Entries_Inner;
|
|
static const UECodeGen_Private::FArrayPropertyParams NewProp_Entries;
|
|
static const UECodeGen_Private::FStructPropertyParams NewProp_BranchInfos_Inner;
|
|
static const UECodeGen_Private::FArrayPropertyParams NewProp_BranchInfos;
|
|
static const UECodeGen_Private::FStructPropertyParams NewProp_PredicateBranches_Inner;
|
|
static const UECodeGen_Private::FArrayPropertyParams NewProp_PredicateBranches;
|
|
static const UECodeGen_Private::FStructPropertyParams NewProp_PublicContextAssetPath;
|
|
static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
|
|
// ********** End ScriptStruct FRigVMByteCode constinit property declarations **********************
|
|
static void* NewStructOps()
|
|
{
|
|
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMByteCode>();
|
|
}
|
|
static const UECodeGen_Private::FStructParams StructParams;
|
|
}; // struct Z_Construct_UScriptStruct_FRigVMByteCode_Statics
|
|
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMByteCode;
|
|
class UScriptStruct* FRigVMByteCode::StaticStruct()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMByteCode.OuterSingleton)
|
|
{
|
|
Z_Registration_Info_UScriptStruct_FRigVMByteCode.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMByteCode, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMByteCode"));
|
|
}
|
|
return Z_Registration_Info_UScriptStruct_FRigVMByteCode.OuterSingleton;
|
|
}
|
|
|
|
// ********** Begin ScriptStruct FRigVMByteCode Property Definitions *******************************
|
|
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_ByteCode_Inner = { "ByteCode", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
|
|
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_ByteCode = { "ByteCode", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, ByteCode), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ByteCode_MetaData), NewProp_ByteCode_MetaData) };
|
|
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_NumInstructions = { "NumInstructions", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, NumInstructions), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_NumInstructions_MetaData), NewProp_NumInstructions_MetaData) };
|
|
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_Entries_Inner = { "Entries", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UScriptStruct_FRigVMByteCodeEntry, METADATA_PARAMS(0, nullptr) }; // 1864448428
|
|
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_Entries = { "Entries", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, Entries), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Entries_MetaData), NewProp_Entries_MetaData) }; // 1864448428
|
|
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_BranchInfos_Inner = { "BranchInfos", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UScriptStruct_FRigVMBranchInfo, METADATA_PARAMS(0, nullptr) }; // 2588872614
|
|
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_BranchInfos = { "BranchInfos", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, BranchInfos), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BranchInfos_MetaData), NewProp_BranchInfos_MetaData) }; // 2588872614
|
|
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PredicateBranches_Inner = { "PredicateBranches", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UScriptStruct_FRigVMPredicateBranch, METADATA_PARAMS(0, nullptr) }; // 3740001603
|
|
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PredicateBranches = { "PredicateBranches", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, PredicateBranches), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PredicateBranches_MetaData), NewProp_PredicateBranches_MetaData) }; // 3740001603
|
|
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PublicContextAssetPath = { "PublicContextAssetPath", nullptr, (EPropertyFlags)0x0040000000000000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMByteCode, PublicContextAssetPath), Z_Construct_UScriptStruct_FTopLevelAssetPath, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PublicContextAssetPath_MetaData), NewProp_PublicContextAssetPath_MetaData) }; // 559680422
|
|
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMByteCode_Statics::PropPointers[] = {
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_ByteCode_Inner,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_ByteCode,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_NumInstructions,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_Entries_Inner,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_Entries,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_BranchInfos_Inner,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_BranchInfos,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PredicateBranches_Inner,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PredicateBranches,
|
|
(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewProp_PublicContextAssetPath,
|
|
};
|
|
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCode_Statics::PropPointers) < 2048);
|
|
// ********** End ScriptStruct FRigVMByteCode Property Definitions *********************************
|
|
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMByteCode_Statics::StructParams = {
|
|
(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
|
|
nullptr,
|
|
&NewStructOps,
|
|
"RigVMByteCode",
|
|
Z_Construct_UScriptStruct_FRigVMByteCode_Statics::PropPointers,
|
|
UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCode_Statics::PropPointers),
|
|
sizeof(FRigVMByteCode),
|
|
alignof(FRigVMByteCode),
|
|
RF_Public|RF_Transient|RF_MarkAsNative,
|
|
EStructFlags(0x00000001),
|
|
METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMByteCode_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMByteCode_Statics::Struct_MetaDataParams)
|
|
};
|
|
UScriptStruct* Z_Construct_UScriptStruct_FRigVMByteCode()
|
|
{
|
|
if (!Z_Registration_Info_UScriptStruct_FRigVMByteCode.InnerSingleton)
|
|
{
|
|
UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMByteCode.InnerSingleton, Z_Construct_UScriptStruct_FRigVMByteCode_Statics::StructParams);
|
|
}
|
|
return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMByteCode.InnerSingleton);
|
|
}
|
|
// ********** End ScriptStruct FRigVMByteCode ******************************************************
|
|
|
|
// ********** Begin Registration *******************************************************************
|
|
struct Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics
|
|
{
|
|
static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
|
|
{ ERigVMOpCode_StaticEnum, TEXT("ERigVMOpCode"), &Z_Registration_Info_UEnum_ERigVMOpCode, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 831061046U) },
|
|
{ ERigVMCopyType_StaticEnum, TEXT("ERigVMCopyType"), &Z_Registration_Info_UEnum_ERigVMCopyType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1495973451U) },
|
|
};
|
|
static constexpr FStructRegisterCompiledInInfo ScriptStructInfo[] = {
|
|
{ FRigVMPredicateBranch::StaticStruct, Z_Construct_UScriptStruct_FRigVMPredicateBranch_Statics::NewStructOps, TEXT("RigVMPredicateBranch"),&Z_Registration_Info_UScriptStruct_FRigVMPredicateBranch, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMPredicateBranch), 3740001603U) },
|
|
{ FRigVMBaseOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMBaseOp_Statics::NewStructOps, TEXT("RigVMBaseOp"),&Z_Registration_Info_UScriptStruct_FRigVMBaseOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMBaseOp), 3847818215U) },
|
|
{ FRigVMExecuteOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMExecuteOp_Statics::NewStructOps, TEXT("RigVMExecuteOp"),&Z_Registration_Info_UScriptStruct_FRigVMExecuteOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMExecuteOp), 3648210654U) },
|
|
{ FRigVMUnaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMUnaryOp_Statics::NewStructOps, TEXT("RigVMUnaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMUnaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMUnaryOp), 187784792U) },
|
|
{ FRigVMBinaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMBinaryOp_Statics::NewStructOps, TEXT("RigVMBinaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMBinaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMBinaryOp), 718044872U) },
|
|
{ FRigVMTernaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMTernaryOp_Statics::NewStructOps, TEXT("RigVMTernaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMTernaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMTernaryOp), 226229003U) },
|
|
{ FRigVMQuaternaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMQuaternaryOp_Statics::NewStructOps, TEXT("RigVMQuaternaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMQuaternaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMQuaternaryOp), 3121665998U) },
|
|
{ FRigVMQuinaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMQuinaryOp_Statics::NewStructOps, TEXT("RigVMQuinaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMQuinaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMQuinaryOp), 1741719786U) },
|
|
{ FRigVMSenaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMSenaryOp_Statics::NewStructOps, TEXT("RigVMSenaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMSenaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMSenaryOp), 1474715002U) },
|
|
{ FRigVMCopyOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMCopyOp_Statics::NewStructOps, TEXT("RigVMCopyOp"),&Z_Registration_Info_UScriptStruct_FRigVMCopyOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMCopyOp), 346262593U) },
|
|
{ FRigVMComparisonOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMComparisonOp_Statics::NewStructOps, TEXT("RigVMComparisonOp"),&Z_Registration_Info_UScriptStruct_FRigVMComparisonOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMComparisonOp), 4219892409U) },
|
|
{ FRigVMJumpOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMJumpOp_Statics::NewStructOps, TEXT("RigVMJumpOp"),&Z_Registration_Info_UScriptStruct_FRigVMJumpOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMJumpOp), 4138235737U) },
|
|
{ FRigVMJumpIfOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMJumpIfOp_Statics::NewStructOps, TEXT("RigVMJumpIfOp"),&Z_Registration_Info_UScriptStruct_FRigVMJumpIfOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMJumpIfOp), 3681425963U) },
|
|
{ FRigVMChangeTypeOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMChangeTypeOp_Statics::NewStructOps, TEXT("RigVMChangeTypeOp"),&Z_Registration_Info_UScriptStruct_FRigVMChangeTypeOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMChangeTypeOp), 210628630U) },
|
|
{ FRigVMInvokeEntryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMInvokeEntryOp_Statics::NewStructOps, TEXT("RigVMInvokeEntryOp"),&Z_Registration_Info_UScriptStruct_FRigVMInvokeEntryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMInvokeEntryOp), 522770672U) },
|
|
{ FRigVMJumpToBranchOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMJumpToBranchOp_Statics::NewStructOps, TEXT("RigVMJumpToBranchOp"),&Z_Registration_Info_UScriptStruct_FRigVMJumpToBranchOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMJumpToBranchOp), 3876138832U) },
|
|
{ FRigVMRunInstructionsOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMRunInstructionsOp_Statics::NewStructOps, TEXT("RigVMRunInstructionsOp"),&Z_Registration_Info_UScriptStruct_FRigVMRunInstructionsOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMRunInstructionsOp), 430741887U) },
|
|
{ FRigVMSetupTraitsOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMSetupTraitsOp_Statics::NewStructOps, TEXT("RigVMSetupTraitsOp"),&Z_Registration_Info_UScriptStruct_FRigVMSetupTraitsOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMSetupTraitsOp), 3651973242U) },
|
|
{ FRigVMInstruction::StaticStruct, Z_Construct_UScriptStruct_FRigVMInstruction_Statics::NewStructOps, TEXT("RigVMInstruction"),&Z_Registration_Info_UScriptStruct_FRigVMInstruction, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMInstruction), 1246216586U) },
|
|
{ FRigVMInstructionArray::StaticStruct, Z_Construct_UScriptStruct_FRigVMInstructionArray_Statics::NewStructOps, TEXT("RigVMInstructionArray"),&Z_Registration_Info_UScriptStruct_FRigVMInstructionArray, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMInstructionArray), 1956721140U) },
|
|
{ FRigVMByteCodeEntry::StaticStruct, Z_Construct_UScriptStruct_FRigVMByteCodeEntry_Statics::NewStructOps, TEXT("RigVMByteCodeEntry"),&Z_Registration_Info_UScriptStruct_FRigVMByteCodeEntry, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMByteCodeEntry), 1864448428U) },
|
|
{ FRigVMByteCode::StaticStruct, Z_Construct_UScriptStruct_FRigVMByteCode_Statics::NewStructOps, TEXT("RigVMByteCode"),&Z_Registration_Info_UScriptStruct_FRigVMByteCode, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMByteCode), 522470654U) },
|
|
};
|
|
}; // Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics
|
|
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_1926836460{
|
|
TEXT("/Script/RigVM"),
|
|
nullptr, 0,
|
|
Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics::ScriptStructInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics::ScriptStructInfo),
|
|
Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMCore_RigVMByteCode_h__Script_RigVM_Statics::EnumInfo),
|
|
};
|
|
// ********** End Registration *********************************************************************
|
|
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|