C++ (Cpp) HK_OFFSET_OF Beispiele

Beispiel #1

Datei: hkbCombineTransformsModifierInternalState_0.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbCombineTransformsModifierInternalStateClass_Members[] =
{
   { "translationOut",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifierInternalState,m_translationOut) /*16*/,HK_NULL},
   { "rotationOut",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifierInternalState,m_rotationOut) /*32*/,HK_NULL},
};

// Signature:  a92ed39f
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbCombineTransformsModifierInternalStateClass;
const hkClass hkbCombineTransformsModifierInternalStateClass(
    "hkbCombineTransformsModifierInternalState",
    &hkReferencedObjectClass, // parent
    sizeof(hkbCombineTransformsModifierInternalState),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbCombineTransformsModifierInternalStateClass_Members), HK_COUNT_OF(hkbCombineTransformsModifierInternalStateClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #2

Datei: hkbFootIkModifierLeg_2.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbFootIkModifierLegClass_Members[] =
{
   { "originalAnkleTransformMS",HK_NULL,HK_NULL,hkClassMember::TYPE_QSTRANSFORM,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_originalAnkleTransformMS) /*0*/,HK_NULL},
   { "prevAnkleRotLS",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbFootIkModifierLeg,m_prevAnkleRotLS) /*48*/,HK_NULL},
   { "kneeAxisLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_kneeAxisLS) /*64*/,HK_NULL},
   { "footEndLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_footEndLS) /*80*/,HK_NULL},
   { "ungroundedEvent",&hkbEventPropertyClass,HK_NULL,hkClassMember::TYPE_STRUCT,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_ungroundedEvent) /*96*/,HK_NULL},
   { "footPlantedAnkleHeightMS",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_footPlantedAnkleHeightMS) /*104*/,HK_NULL},
   { "footRaisedAnkleHeightMS",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_footRaisedAnkleHeightMS) /*108*/,HK_NULL},
   { "maxAnkleHeightMS",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_maxAnkleHeightMS) /*112*/,HK_NULL},
   { "minAnkleHeightMS",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_minAnkleHeightMS) /*116*/,HK_NULL},
   { "maxKneeAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_maxKneeAngleDegrees) /*120*/,HK_NULL},
   { "minKneeAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_minKneeAngleDegrees) /*124*/,HK_NULL},
   { "verticalError",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_verticalError) /*128*/,HK_NULL},
   { "maxAnkleAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_maxAnkleAngleDegrees) /*132*/,HK_NULL},
   { "hipIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_hipIndex) /*136*/,HK_NULL},
   { "kneeIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_kneeIndex) /*138*/,HK_NULL},
   { "ankleIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierLeg,m_ankleIndex) /*140*/,HK_NULL},

Beispiel #3

Datei: hkbLookAtModifier_3.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbLookAtModifierClass_Members[] =
{
   { "targetWS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_targetWS) /*48*/,HK_NULL},
   { "headForwardLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_headForwardLS) /*64*/,HK_NULL},
   { "neckForwardLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_neckForwardLS) /*80*/,HK_NULL},
   { "neckRightLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_neckRightLS) /*96*/,HK_NULL},
   { "eyePositionHS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_eyePositionHS) /*112*/,HK_NULL},
   { "newTargetGain",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_newTargetGain) /*128*/,HK_NULL},
   { "onGain",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_onGain) /*132*/,HK_NULL},
   { "offGain",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_offGain) /*136*/,HK_NULL},
   { "limitAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_limitAngleDegrees) /*140*/,HK_NULL},
   { "limitAngleLeft",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_limitAngleLeft) /*144*/,HK_NULL},
   { "limitAngleRight",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_limitAngleRight) /*148*/,HK_NULL},
   { "limitAngleUp",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_limitAngleUp) /*152*/,HK_NULL},
   { "limitAngleDown",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_limitAngleDown) /*156*/,HK_NULL},
   { "headIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_headIndex) /*160*/,HK_NULL},
   { "neckIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_neckIndex) /*162*/,HK_NULL},
   { "isOn",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLookAtModifier,m_isOn) /*164*/,HK_NULL},

Beispiel #4

Datei: hkbTestStateChooser_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbTestStateChooserClass_Members[] =
{
   { "int",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbTestStateChooser,m_int) /*8*/,HK_NULL},
   { "real",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbTestStateChooser,m_real) /*12*/,HK_NULL},
   { "string",HK_NULL,HK_NULL,hkClassMember::TYPE_STRINGPTR,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbTestStateChooser,m_string) /*16*/,HK_NULL},
};

// Signature:  c0fcc436
extern const hkClass hkbStateChooserClass;
extern const hkClass hkbTestStateChooserClass;
const hkClass hkbTestStateChooserClass(
    "hkbTestStateChooser",
    &hkbStateChooserClass, // parent
    sizeof(hkbTestStateChooser),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbTestStateChooserClass_Members), HK_COUNT_OF(hkbTestStateChooserClass_Members),
    HK_NULL, // defaults

Beispiel #5

Datei: hkbCharacterDataCharacterControllerInfo_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbCharacterDataCharacterControllerInfoClass_Members[] =
{
   { "capsuleHeight",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterDataCharacterControllerInfo,m_capsuleHeight) /*0*/,HK_NULL},
   { "capsuleRadius",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterDataCharacterControllerInfo,m_capsuleRadius) /*4*/,HK_NULL},
   { "collisionFilterInfo",HK_NULL,HK_NULL,hkClassMember::TYPE_UINT32,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterDataCharacterControllerInfo,m_collisionFilterInfo) /*8*/,HK_NULL},
   { "characterControllerCinfo",&hkpCharacterControllerCinfoClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterDataCharacterControllerInfo,m_characterControllerCinfo) /*12*/,HK_NULL},
};

// Signature:  a0f415bf
extern const hkClass hkbCharacterDataCharacterControllerInfoClass;
const hkClass hkbCharacterDataCharacterControllerInfoClass(
    "hkbCharacterDataCharacterControllerInfo",
    HK_NULL, // parent
    sizeof(hkbCharacterDataCharacterControllerInfo),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbCharacterDataCharacterControllerInfoClass_Members), HK_COUNT_OF(hkbCharacterDataCharacterControllerInfoClass_Members),
    HK_NULL, // defaults

Beispiel #6

Datei: hkbRoleAttribute_0.cpp Projekt: KageKirin/hkxcmd

   {4, "FLAG_NOT_VARIABLE"},
   {8, "FLAG_HIDDEN"},
   {16, "FLAG_OUTPUT"},
   {32, "FLAG_NOT_CHARACTER_PROPERTY"},
};

static const hkInternalClassEnum hkbRoleAttributeClass_Enums[] = {
   {"Role", RoleEnumItems, _countof(RoleEnumItems), HK_NULL, 0 },
   {"RoleFlags", RoleFlagsEnumItems, _countof(RoleFlagsEnumItems), HK_NULL, 0 },
};
const hkClassEnum* RoleEnum = reinterpret_cast<const hkClassEnum*>(&hkbRoleAttributeClass_Enums[0]);
const hkClassEnum* RoleFlagsEnum = reinterpret_cast<const hkClassEnum*>(&hkbRoleAttributeClass_Enums[1]);

static const hkInternalClassMember hkbRoleAttributeClass_Members[] =
{
   { "role",HK_NULL,RoleEnum,hkClassMember::TYPE_ENUM,hkClassMember::TYPE_INT16,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbRoleAttribute,m_role) /*0*/,HK_NULL},
   { "flags",HK_NULL,RoleFlagsEnum,hkClassMember::TYPE_FLAGS,hkClassMember::TYPE_INT16,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbRoleAttribute,m_flags) /*2*/,HK_NULL},
};

// Signature:  3eb2e082
extern const hkClass hkbRoleAttributeClass;
const hkClass hkbRoleAttributeClass(
    "hkbRoleAttribute",
    HK_NULL, // parent
    sizeof(hkbRoleAttribute),
    HK_NULL, 0, // interfaces
    reinterpret_cast<const hkClassEnum*>(hkbRoleAttributeClass_Enums), HK_COUNT_OF(hkbRoleAttributeClass_Enums),
    reinterpret_cast<const hkClassMember*>(hkbRoleAttributeClass_Members), HK_COUNT_OF(hkbRoleAttributeClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #7

Datei: hkbPoweredRagdollControlsModifier_5.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbPoweredRagdollControlsModifierClass_Members[] =
{
   { "controlData",&hkbPoweredRagdollControlDataClass,HK_NULL,hkClassMember::TYPE_STRUCT,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlsModifier,m_controlData) /*48*/,HK_NULL},
   { "bones",&hkbBoneIndexArrayClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlsModifier,m_bones) /*80*/,HK_NULL},
   { "worldFromModelModeData",&hkbWorldFromModelModeDataClass,HK_NULL,hkClassMember::TYPE_STRUCT,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlsModifier,m_worldFromModelModeData) /*84*/,HK_NULL},
   { "boneWeights",&hkbBoneWeightArrayClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlsModifier,m_boneWeights) /*92*/,HK_NULL},
};

// Signature:  7cb54065
extern const hkClass hkbModifierClass;
extern const hkClass hkbPoweredRagdollControlsModifierClass;
const hkClass hkbPoweredRagdollControlsModifierClass(
    "hkbPoweredRagdollControlsModifier",
    &hkbModifierClass, // parent
    sizeof(hkbPoweredRagdollControlsModifier),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbPoweredRagdollControlsModifierClass_Members), HK_COUNT_OF(hkbPoweredRagdollControlsModifierClass_Members),

Beispiel #8

Datei: hkbAttributeModifierAssignment_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbAttributeModifierAssignmentClass_Members[] =
{
   { "attributeIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbAttributeModifierAssignment,m_attributeIndex) /*0*/,HK_NULL},
   { "attributeValue",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbAttributeModifierAssignment,m_attributeValue) /*4*/,HK_NULL},
};

// Signature:  48b8ad52
extern const hkClass hkbAttributeModifierAssignmentClass;
const hkClass hkbAttributeModifierAssignmentClass(
    "hkbAttributeModifierAssignment",
    HK_NULL, // parent
    sizeof(hkbAttributeModifierAssignment),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbAttributeModifierAssignmentClass_Members), HK_COUNT_OF(hkbAttributeModifierAssignmentClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #9

Datei: hkbNamedStringEventPayload_0.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbNamedStringEventPayloadClass_Members[] =
{
   { "data",HK_NULL,HK_NULL,hkClassMember::TYPE_STRINGPTR,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbNamedStringEventPayload,m_data) /*12*/,HK_NULL},
};

// Signature:  6caa9113
extern const hkClass hkbNamedEventPayloadClass;
extern const hkClass hkbNamedStringEventPayloadClass;
const hkClass hkbNamedStringEventPayloadClass(
    "hkbNamedStringEventPayload",
    &hkbNamedEventPayloadClass, // parent
    sizeof(hkbNamedStringEventPayload),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbNamedStringEventPayloadClass_Members), HK_COUNT_OF(hkbNamedStringEventPayloadClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #10

Datei: hkbSequenceInternalState_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbSequenceInternalStateClass_Members[] =
{
   { "nextSampleEvents",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_INT32,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_nextSampleEvents) /*8*/,HK_NULL},
   { "nextSampleReals",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_INT32,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_nextSampleReals) /*20*/,HK_NULL},
   { "nextSampleBools",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_INT32,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_nextSampleBools) /*32*/,HK_NULL},
   { "nextSampleInts",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_INT32,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_nextSampleInts) /*44*/,HK_NULL},
   { "time",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_time) /*56*/,HK_NULL},
   { "isEnabled",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbSequenceInternalState,m_isEnabled) /*60*/,HK_NULL},
};

// Signature:  419b9a05
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbSequenceInternalStateClass;
const hkClass hkbSequenceInternalStateClass(
    "hkbSequenceInternalState",
    &hkReferencedObjectClass, // parent
    sizeof(hkbSequenceInternalState),
    HK_NULL, 0, // interfaces

Beispiel #11

Datei: vHavokVisionShapesReflection.cpp Projekt: cDoru/projectanarchy

#define False false


// External pointer and enum types
extern const hkClass VTerrainSectorClass;
extern const hkClass hkBitFieldClass;
extern const hkClass hkvMeshMaterialClass;

//
// Class hkvConvexVerticesShape
//
extern const hkClass hkpConvexVerticesShapeClass;

const hkInternalClassMember hkvConvexVerticesShape::Members[] =
{
	{ "iFileTime", HK_NULL, HK_NULL, hkClassMember::TYPE_INT64, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(hkvConvexVerticesShape,m_iFileTime), HK_NULL }
};
extern const hkClass hkvConvexVerticesShapeClass;
const hkClass hkvConvexVerticesShapeClass(
	"hkvConvexVerticesShape",
	&hkpConvexVerticesShapeClass, // parent
	sizeof(::hkvConvexVerticesShape),
	HK_NULL,
	0, // interfaces
	HK_NULL,
	0, // enums
	reinterpret_cast<const hkClassMember*>(hkvConvexVerticesShape::Members),
	HK_COUNT_OF(hkvConvexVerticesShape::Members),
	HK_NULL, // defaults
	HK_NULL, // attributes
	0, // flags

Beispiel #12

Datei: hkbMessageLog_0.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbMessageLogClass_Members[] =
{
   { "messages",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbMessageLog,m_messages) /*0*/,HK_NULL},
   { "maxMessages",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbMessageLog,m_maxMessages) /*4*/,HK_NULL},
};

// Signature:  26a196c5
extern const hkClass hkbMessageLogClass;
const hkClass hkbMessageLogClass(
    "hkbMessageLog",
    HK_NULL, // parent
    sizeof(hkbMessageLog),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbMessageLogClass_Members), HK_COUNT_OF(hkbMessageLogClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #13

Datei: hkbIntVariableSequencedData_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbIntVariableSequencedDataClass_Members[] =
{
   { "samples",&hkbIntVariableSequencedDataSampleClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbIntVariableSequencedData,m_samples) /*8*/,HK_NULL},
   { "variableIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbIntVariableSequencedData,m_variableIndex) /*20*/,HK_NULL},
};

// Signature:  7bfc518a
extern const hkClass hkbSequencedDataClass;
extern const hkClass hkbIntVariableSequencedDataClass;
const hkClass hkbIntVariableSequencedDataClass(
    "hkbIntVariableSequencedData",
    &hkbSequencedDataClass, // parent
    sizeof(hkbIntVariableSequencedData),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbIntVariableSequencedDataClass_Members), HK_COUNT_OF(hkbIntVariableSequencedDataClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #14

Datei: hkbPoweredRagdollControlData_3.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbPoweredRagdollControlDataClass_Members[] =
{
   { "maxForce",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::ALIGN_16,HK_OFFSET_OF(hkbPoweredRagdollControlData,m_maxForce) /*0*/,HK_NULL},
   { "tau",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlData,m_tau) /*4*/,HK_NULL},
   { "damping",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlData,m_damping) /*8*/,HK_NULL},
   { "proportionalRecoveryVelocity",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlData,m_proportionalRecoveryVelocity) /*12*/,HK_NULL},
   { "constantRecoveryVelocity",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbPoweredRagdollControlData,m_constantRecoveryVelocity) /*16*/,HK_NULL},
};

// Signature:  0f5ba21b
extern const hkClass hkbPoweredRagdollControlDataClass;
const hkClass hkbPoweredRagdollControlDataClass(
    "hkbPoweredRagdollControlData",
    HK_NULL, // parent
    sizeof(hkbPoweredRagdollControlData),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbPoweredRagdollControlDataClass_Members), HK_COUNT_OF(hkbPoweredRagdollControlDataClass_Members),

Beispiel #15

Datei: hkbFootIkModifierInternalLegData_1.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbFootIkModifierInternalLegDataClass_Members[] =
{
   { "groundPosition",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbFootIkModifierInternalLegData,m_groundPosition) /*0*/,HK_NULL},
   { "footIkSolver",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbFootIkModifierInternalLegData,m_footIkSolver) /*16*/,HK_NULL},
};

// Signature:  e5ca3677
extern const hkClass hkbFootIkModifierInternalLegDataClass;
const hkClass hkbFootIkModifierInternalLegDataClass(
    "hkbFootIkModifierInternalLegData",
    HK_NULL, // parent
    sizeof(hkbFootIkModifierInternalLegData),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbFootIkModifierInternalLegDataClass_Members), HK_COUNT_OF(hkbFootIkModifierInternalLegDataClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #16

Datei: hkbGeneratorTransitionEffectInternalState_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>

extern const hkClassEnum* ToGeneratorStateEnum;
extern const hkClassEnum* StageEnum;

static const hkInternalClassMember hkbGeneratorTransitionEffectInternalStateClass_Members[] =
{
   { "timeInTransition",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_timeInTransition) /*8*/,HK_NULL},
   { "duration",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_duration) /*12*/,HK_NULL},
   { "effectiveBlendInDuration",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_effectiveBlendInDuration) /*16*/,HK_NULL},
   { "effectiveBlendOutDuration",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_effectiveBlendOutDuration) /*20*/,HK_NULL},
   { "toGeneratorState",HK_NULL,ToGeneratorStateEnum,hkClassMember::TYPE_ENUM,hkClassMember::TYPE_INT8,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_toGeneratorState) /*24*/,HK_NULL},
   { "echoTransitionGenerator",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_echoTransitionGenerator) /*25*/,HK_NULL},
   { "echoToGenerator",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_echoToGenerator) /*26*/,HK_NULL},
   { "justActivated",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_justActivated) /*27*/,HK_NULL},
   { "updateActiveNodes",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_updateActiveNodes) /*28*/,HK_NULL},
   { "stage",HK_NULL,StageEnum,hkClassMember::TYPE_ENUM,hkClassMember::TYPE_INT8,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbGeneratorTransitionEffectInternalState,m_stage) /*29*/,HK_NULL},
};

// Signature:  d6692b5d
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbGeneratorTransitionEffectInternalStateClass;
const hkClass hkbGeneratorTransitionEffectInternalStateClass(

Beispiel #17

Datei: hkbBehaviorGraphData_2.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbBehaviorGraphDataClass_Members[] =
{
   { "attributeDefaults",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_REAL,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_attributeDefaults) /*8*/,HK_NULL},
   { "variableInfos",&hkbVariableInfoClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_variableInfos) /*20*/,HK_NULL},
   { "characterPropertyInfos",&hkbVariableInfoClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_characterPropertyInfos) /*32*/,HK_NULL},
   { "eventInfos",&hkbEventInfoClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_eventInfos) /*44*/,HK_NULL},
   { "wordMinVariableValues",&hkbVariableValueClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_wordMinVariableValues) /*56*/,HK_NULL},
   { "wordMaxVariableValues",&hkbVariableValueClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_wordMaxVariableValues) /*68*/,HK_NULL},
   { "variableInitialValues",&hkbVariableValueSetClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_variableInitialValues) /*80*/,HK_NULL},
   { "stringData",&hkbBehaviorGraphStringDataClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBehaviorGraphData,m_stringData) /*84*/,HK_NULL},
};

// Signature:  095aca5d
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbBehaviorGraphDataClass;
const hkClass hkbBehaviorGraphDataClass(
    "hkbBehaviorGraphData",
    &hkReferencedObjectClass, // parent

Beispiel #18

Datei: hkbExpressionCondition_1.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbExpressionConditionClass_Members[] =
{
   { "expression",HK_NULL,HK_NULL,hkClassMember::TYPE_STRINGPTR,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbExpressionCondition,m_expression) /*8*/,HK_NULL},
   { "compiledExpressionSet",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbExpressionCondition,m_compiledExpressionSet) /*12*/,HK_NULL},
};

// Signature:  1c3c1045
extern const hkClass hkbConditionClass;
extern const hkClass hkbExpressionConditionClass;
const hkClass hkbExpressionConditionClass(
    "hkbExpressionCondition",
    &hkbConditionClass, // parent
    sizeof(hkbExpressionCondition),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbExpressionConditionClass_Members), HK_COUNT_OF(hkbExpressionConditionClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #19

Datei: hkbBlenderGenerator_1.cpp Projekt: KageKirin/hkxcmd

   {1, "FLAG_SYNC"},
   {4, "FLAG_SMOOTH_GENERATOR_WEIGHTS"},
   {8, "FLAG_DONT_DEACTIVATE_CHILDREN_WITH_ZERO_WEIGHTS"},
   {16, "FLAG_PARAMETRIC_BLEND"},
   {32, "FLAG_IS_PARAMETRIC_BLEND_CYCLIC"},
   {64, "FLAG_FORCE_DENSE_POSE"},
};

static const hkInternalClassEnum hkbBlenderGeneratorClass_Enums[] = {
   {"BlenderFlags", BlenderFlagsEnumItems, _countof(BlenderFlagsEnumItems), HK_NULL, 0 },
};
const hkClassEnum* BlenderFlagsEnum = reinterpret_cast<const hkClassEnum*>(&hkbBlenderGeneratorClass_Enums[0]);

static const hkInternalClassMember hkbBlenderGeneratorClass_Members[] =
{
   { "referencePoseWeightThreshold",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_referencePoseWeightThreshold) /*40*/,HK_NULL},
   { "blendParameter",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_blendParameter) /*44*/,HK_NULL},
   { "minCyclicBlendParameter",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_minCyclicBlendParameter) /*48*/,HK_NULL},
   { "maxCyclicBlendParameter",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_maxCyclicBlendParameter) /*52*/,HK_NULL},
   { "indexOfSyncMasterChild",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_indexOfSyncMasterChild) /*56*/,HK_NULL},
   { "flags",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_flags) /*58*/,HK_NULL},
   { "subtractLastChild",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_subtractLastChild) /*60*/,HK_NULL},
   { "children",&hkbBlenderGeneratorChildClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_POINTER,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGenerator,m_children) /*64*/,HK_NULL},
   { "childrenInternalStates",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_childrenInternalStates) /*76*/,HK_NULL},
   { "sortedChildren",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_sortedChildren) /*88*/,HK_NULL},
   { "endIntervalWeight",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_endIntervalWeight) /*100*/,HK_NULL},
   { "numActiveChildren",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_numActiveChildren) /*104*/,HK_NULL},
   { "beginIntervalIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_beginIntervalIndex) /*108*/,HK_NULL},
   { "endIntervalIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_endIntervalIndex) /*110*/,HK_NULL},
   { "initSync",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_initSync) /*112*/,HK_NULL},
   { "doSubtractiveBlend",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbBlenderGenerator,m_doSubtractiveBlend) /*113*/,HK_NULL},

Beispiel #20

Datei: hkbCombineTransformsModifier_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbCombineTransformsModifierClass_Members[] =
{
   { "translationOut",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_translationOut) /*48*/,HK_NULL},
   { "rotationOut",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_rotationOut) /*64*/,HK_NULL},
   { "leftTranslation",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_leftTranslation) /*80*/,HK_NULL},
   { "leftRotation",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_leftRotation) /*96*/,HK_NULL},
   { "rightTranslation",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_rightTranslation) /*112*/,HK_NULL},
   { "rightRotation",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_rightRotation) /*128*/,HK_NULL},
   { "invertLeftTransform",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_invertLeftTransform) /*144*/,HK_NULL},
   { "invertRightTransform",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_invertRightTransform) /*145*/,HK_NULL},
   { "invertResult",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCombineTransformsModifier,m_invertResult) /*146*/,HK_NULL},
};

// Signature:  fd1f0b79
extern const hkClass hkbModifierClass;
extern const hkClass hkbCombineTransformsModifierClass;
const hkClass hkbCombineTransformsModifierClass(
    "hkbCombineTransformsModifier",

Beispiel #21

Datei: hkbCharacterSetup_2.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbCharacterSetupClass_Members[] =
{
   { "retargetingSkeletonMappers",&hkaSkeletonMapperClass,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_POINTER,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterSetup,m_retargetingSkeletonMappers) /*8*/,HK_NULL},
   { "animationSkeleton",&hkaSkeletonClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterSetup,m_animationSkeleton) /*20*/,HK_NULL},
   { "ragdollToAnimationSkeletonMapper",&hkaSkeletonMapperClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterSetup,m_ragdollToAnimationSkeletonMapper) /*24*/,HK_NULL},
   { "animationToRagdollSkeletonMapper",&hkaSkeletonMapperClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterSetup,m_animationToRagdollSkeletonMapper) /*28*/,HK_NULL},
   { "animationBindingSet",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbCharacterSetup,m_animationBindingSet) /*32*/,HK_NULL},
   { "data",&hkbCharacterDataClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbCharacterSetup,m_data) /*36*/,HK_NULL},
   { "mirroredSkeleton",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbCharacterSetup,m_mirroredSkeleton) /*40*/,HK_NULL},
   { "characterPropertyIdMap",HK_NULL,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_VOID,0,hkClassMember::SERIALIZE_IGNORED,HK_OFFSET_OF(hkbCharacterSetup,m_characterPropertyIdMap) /*44*/,HK_NULL},
};

// Signature:  e5a2a413
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbCharacterSetupClass;
const hkClass hkbCharacterSetupClass(
    "hkbCharacterSetup",
    &hkReferencedObjectClass, // parent

Beispiel #22

#define True true
#define False false



// External pointer and enum types
extern const hkClass hkpCharacterContextClass;
extern const hkClass hkpCharacterProxyClass;
extern const hkClass hkpShapePhantomClass;

//
// Class StairClimbingDemo::Options
//
static const hkInternalClassMember StairClimbingDemo_OptionsClass_Members[] =
{
	{ "worldCollisionTolerance", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_worldCollisionTolerance), HK_NULL },
	{ "characterCylinderHeight", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_characterCylinderHeight), HK_NULL },
	{ "characterRadius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_characterRadius), HK_NULL },
	{ "maxSlope", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_maxSlope), HK_NULL },
	{ "numStaircases", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_numStaircases), HK_NULL },
	{ "numStepsStart", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_numStepsStart), HK_NULL },
	{ "numStepsIncrement", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_numStepsIncrement), HK_NULL },
	{ "stairsRun", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_stairsRun), HK_NULL },
	{ "stairsRise", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_stairsRise), HK_NULL },
	{ "stepConvexRadius", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(StairClimbingDemo::Options,m_stepConvexRadius), HK_NULL }
};
namespace
{
	struct StairClimbingDemoOptions_DefaultStruct
	{
		int s_defaultOffsets[10];

Beispiel #23

static const hkInternalCustomAttributes ClassWithAttributes_name_Attributes = { ClassWithAttributes_name_AttributesList, HK_COUNT_OF(ClassWithAttributes_name_AttributesList) };
// ClassWithAttributes attributes
static const ExampleBooleanAttribute ClassWithAttributes_ExampleVisibleInTool = { true };
static const ExampleStringAttribute ClassWithAttributes_ExampleIconPath = { "resources/icons/CustomAttributes.png" };
static const int ClassWithAttributes_ExampleGuiLayoutOrder_items[] = { 4, 0, 1 };
static const ExampleIntListAttribute ClassWithAttributes_ExampleGuiLayoutOrder = { ClassWithAttributes_ExampleGuiLayoutOrder_items, HK_COUNT_OF(ClassWithAttributes_ExampleGuiLayoutOrder_items) };
static const hkInternalCustomAttributes::Attribute ClassWithAttributes_AttributesList[] =
{
	{ "Example.VisibleInTool", &ClassWithAttributes_ExampleVisibleInTool, &ExampleBooleanAttributeClass },
	{ "Example.IconPath", &ClassWithAttributes_ExampleIconPath, &ExampleStringAttributeClass },
	{ "Example.GuiLayoutOrder", &ClassWithAttributes_ExampleGuiLayoutOrder, &ExampleIntListAttributeClass }
};
static const hkInternalCustomAttributes ClassWithAttributes_Attributes = { ClassWithAttributes_AttributesList, HK_COUNT_OF(ClassWithAttributes_AttributesList) };
static const hkInternalClassMember ClassWithAttributesClass_Members[] =
{
	{ "mass", HK_NULL, HK_NULL, hkClassMember::TYPE_INT32, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(ClassWithAttributes,m_mass), &ClassWithAttributes_mass_Attributes },
	{ "restitution", HK_NULL, HK_NULL, hkClassMember::TYPE_REAL, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(ClassWithAttributes,m_restitution), &ClassWithAttributes_restitution_Attributes },
	{ "pathToResource", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(ClassWithAttributes,m_pathToResource), &ClassWithAttributes_pathToResource_Attributes },
	{ "name", HK_NULL, HK_NULL, hkClassMember::TYPE_CSTRING, hkClassMember::TYPE_VOID, 0, 0, HK_OFFSET_OF(ClassWithAttributes,m_name), &ClassWithAttributes_name_Attributes }
};
extern const hkClass ClassWithAttributesClass;
const hkClass ClassWithAttributesClass(
	"ClassWithAttributes",
	HK_NULL, // parent
	sizeof(ClassWithAttributes),
	HK_NULL,
	0, // interfaces
	HK_NULL,
	0, // enums
	reinterpret_cast<const hkClassMember*>(ClassWithAttributesClass_Members),
	HK_COUNT_OF(ClassWithAttributesClass_Members),

Beispiel #24

Datei: hkbHandIkControlsModifierHand_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbHandIkControlsModifierHandClass_Members[] =
{
   { "controlData",&hkbHandIkControlDataClass,HK_NULL,hkClassMember::TYPE_STRUCT,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkControlsModifierHand,m_controlData) /*0*/,HK_NULL},
   { "handIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT32,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkControlsModifierHand,m_handIndex) /*80*/,HK_NULL},
   { "enable",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkControlsModifierHand,m_enable) /*84*/,HK_NULL},
};

// Signature:  9c72e9e3
extern const hkClass hkbHandIkControlsModifierHandClass;
const hkClass hkbHandIkControlsModifierHandClass(
    "hkbHandIkControlsModifierHand",
    HK_NULL, // parent
    sizeof(hkbHandIkControlsModifierHand),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbHandIkControlsModifierHandClass_Members), HK_COUNT_OF(hkbHandIkControlsModifierHandClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #25

Datei: hkbLinkedSymbolInfo_0.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbLinkedSymbolInfoClass_Members[] =
{
   { "eventNames",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRINGPTR,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLinkedSymbolInfo,m_eventNames) /*8*/,HK_NULL},
   { "variableNames",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_STRINGPTR,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbLinkedSymbolInfo,m_variableNames) /*20*/,HK_NULL},
};

// Signature:  6a5094e3
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbLinkedSymbolInfoClass;
const hkClass hkbLinkedSymbolInfoClass(
    "hkbLinkedSymbolInfo",
    &hkReferencedObjectClass, // parent
    sizeof(hkbLinkedSymbolInfo),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbLinkedSymbolInfoClass_Members), HK_COUNT_OF(hkbLinkedSymbolInfoClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #26

Datei: hkbModifierGenerator_0.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbModifierGeneratorClass_Members[] =
{
   { "modifier",&hkbModifierClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbModifierGenerator,m_modifier) /*40*/,HK_NULL},
   { "generator",&hkbGeneratorClass,HK_NULL,hkClassMember::TYPE_POINTER,hkClassMember::TYPE_STRUCT,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbModifierGenerator,m_generator) /*44*/,HK_NULL},
};

// Signature:  1f81fae6
extern const hkClass hkbGeneratorClass;
extern const hkClass hkbModifierGeneratorClass;
const hkClass hkbModifierGeneratorClass(
    "hkbModifierGenerator",
    &hkbGeneratorClass, // parent
    sizeof(hkbModifierGenerator),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbModifierGeneratorClass_Members), HK_COUNT_OF(hkbModifierGeneratorClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #27

Datei: hkbEventsFromRangeModifierInternalState_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbEventsFromRangeModifierInternalStateClass_Members[] =
{
   { "wasActiveInPreviousFrame",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_BOOL,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbEventsFromRangeModifierInternalState,m_wasActiveInPreviousFrame) /*8*/,HK_NULL},
};

// Signature:  cc47b48d
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbEventsFromRangeModifierInternalStateClass;
const hkClass hkbEventsFromRangeModifierInternalStateClass(
    "hkbEventsFromRangeModifierInternalState",
    &hkReferencedObjectClass, // parent
    sizeof(hkbEventsFromRangeModifierInternalState),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbEventsFromRangeModifierInternalStateClass_Members), HK_COUNT_OF(hkbEventsFromRangeModifierInternalStateClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #28

Datei: hkbMirroredSkeletonInfo_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbMirroredSkeletonInfoClass_Members[] =
{
   { "mirrorAxis",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbMirroredSkeletonInfo,m_mirrorAxis) /*16*/,HK_NULL},
   { "bonePairMap",HK_NULL,HK_NULL,hkClassMember::TYPE_ARRAY,hkClassMember::TYPE_INT16,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbMirroredSkeletonInfo,m_bonePairMap) /*32*/,HK_NULL},
};

// Signature:  c6c2da4f
extern const hkClass hkReferencedObjectClass;
extern const hkClass hkbMirroredSkeletonInfoClass;
const hkClass hkbMirroredSkeletonInfoClass(
    "hkbMirroredSkeletonInfo",
    &hkReferencedObjectClass, // parent
    sizeof(hkbMirroredSkeletonInfo),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbMirroredSkeletonInfoClass_Members), HK_COUNT_OF(hkbMirroredSkeletonInfoClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes

Beispiel #29

Datei: hkbBlenderGeneratorChildInternalState_0.cpp Projekt: nexustheru/nifskope-hybrid

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbBlenderGeneratorChildInternalStateClass_Members[] =
{
   { "isActive",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGeneratorChildInternalState,m_isActive) /*0*/,HK_NULL},
   { "syncNextFrame",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbBlenderGeneratorChildInternalState,m_syncNextFrame) /*1*/,HK_NULL},
};

// Signature:  ff7327c0
extern const hkClass hkbBlenderGeneratorChildInternalStateClass;
const hkClass hkbBlenderGeneratorChildInternalStateClass(
    "hkbBlenderGeneratorChildInternalState",
    HK_NULL, // parent
    sizeof(hkbBlenderGeneratorChildInternalState),
    HK_NULL, 0, // interfaces
    HK_NULL, 0, // enums
    reinterpret_cast<const hkClassMember*>(hkbBlenderGeneratorChildInternalStateClass_Members), HK_COUNT_OF(hkbBlenderGeneratorChildInternalStateClass_Members),
    HK_NULL, // defaults
    HK_NULL, // attributes
    0, // flags

Beispiel #30

Datei: hkbHandIkDriverInfoHand_1.cpp Projekt: KageKirin/hkxcmd

#include <Common/Serialize/Util/hkSerializeUtil.h>
#include <Common/Serialize/Version/hkVersionPatchManager.h>
#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>
#include <Common/Serialize/Data/Native/hkDataObjectNative.h>
#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>
#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>
#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>
#include <Common/Base/Reflection/hkClass.h>
#include <Common/Base/Reflection/hkInternalClassMember.h>
#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>
#include <Common/Serialize/Util/hkVersionCheckingUtils.h>


static const hkInternalClassMember hkbHandIkDriverInfoHandClass_Members[] =
{
   { "elbowAxisLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_elbowAxisLS) /*0*/,HK_NULL},
   { "backHandNormalLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_backHandNormalLS) /*16*/,HK_NULL},
   { "handOffsetLS",HK_NULL,HK_NULL,hkClassMember::TYPE_VECTOR4,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_handOffsetLS) /*32*/,HK_NULL},
   { "handOrienationOffsetLS",HK_NULL,HK_NULL,hkClassMember::TYPE_QUATERNION,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_handOrienationOffsetLS) /*48*/,HK_NULL},
   { "maxElbowAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_maxElbowAngleDegrees) /*64*/,HK_NULL},
   { "minElbowAngleDegrees",HK_NULL,HK_NULL,hkClassMember::TYPE_REAL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_minElbowAngleDegrees) /*68*/,HK_NULL},
   { "shoulderIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_shoulderIndex) /*72*/,HK_NULL},
   { "shoulderSiblingIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_shoulderSiblingIndex) /*74*/,HK_NULL},
   { "elbowIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_elbowIndex) /*76*/,HK_NULL},
   { "elbowSiblingIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_elbowSiblingIndex) /*78*/,HK_NULL},
   { "wristIndex",HK_NULL,HK_NULL,hkClassMember::TYPE_INT16,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_wristIndex) /*80*/,HK_NULL},
   { "enforceEndPosition",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_enforceEndPosition) /*82*/,HK_NULL},
   { "enforceEndRotation",HK_NULL,HK_NULL,hkClassMember::TYPE_BOOL,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_enforceEndRotation) /*83*/,HK_NULL},
   { "localFrameName",HK_NULL,HK_NULL,hkClassMember::TYPE_STRINGPTR,hkClassMember::TYPE_VOID,0,hkClassMember::FLAGS_NONE,HK_OFFSET_OF(hkbHandIkDriverInfoHand,m_localFrameName) /*84*/,HK_NULL},
};