├── .clang-format ├── .clang-tidy ├── .editorconfig ├── .gitattributes ├── .github └── workflows │ ├── main_ci.yml │ └── maintenance.yml ├── .gitignore ├── LICENSE ├── README.md ├── include ├── F4SE │ ├── API.h │ ├── F4SE.h │ ├── Impl │ │ └── PCH.h │ ├── InputMap.h │ ├── Interfaces.h │ ├── Trampoline.h │ └── Version.h ├── RE │ ├── A │ │ ├── ACTION_OBJECT.h │ │ ├── ACTOR_BASE_DATA.h │ │ ├── ACTOR_CRITICAL_STAGE.h │ │ ├── ACTOR_LIFE_STATE.h │ │ ├── ACTOR_LOS_LOCATION.h │ │ ├── ACTOR_VALUE_MODIFIER.h │ │ ├── ACTOR_VISIBILITY_MASK.h │ │ ├── ADDON_DATA.h │ │ ├── AIDATA_GAME.h │ │ ├── AIProcess.h │ │ ├── AITimeStamp.h │ │ ├── AITimer.h │ │ ├── AMMO_DATA.h │ │ ├── ActionInput.h │ │ ├── ActiveEffect.h │ │ ├── ActiveEffectList.h │ │ ├── ActiveEffectReferenceEffectController.h │ │ ├── Actor.h │ │ ├── ActorEquipManager.h │ │ ├── ActorEquipManagerEvent.h │ │ ├── ActorItemEquipped.h │ │ ├── ActorKill.h │ │ ├── ActorPackage.h │ │ ├── ActorPackageData.h │ │ ├── ActorState.h │ │ ├── ActorUtils.h │ │ ├── ActorValue.h │ │ ├── ActorValueEvents.h │ │ ├── ActorValueInfo.h │ │ ├── ActorValueOwner.h │ │ ├── ActorValueStorage.h │ │ ├── AimModel.h │ │ ├── AlarmPackage.h │ │ ├── AlchemyItem.h │ │ ├── AnimationStanceNodeLocationData.h │ │ ├── AnimationSystemUtils.h │ │ ├── ApplyChangesFunctor.h │ │ ├── ApplyColorUpdateEvent.h │ │ ├── ArrowProjectile.h │ │ ├── AttachTechniqueInput.h │ │ ├── AttackBlockHandler.h │ │ ├── AttackData.h │ │ └── AutoMoveHandler.h │ ├── B │ │ ├── BGSAcousticSpace.h │ │ ├── BGSAction.h │ │ ├── BGSActorCellEvent.h │ │ ├── BGSActorDeathEvent.h │ │ ├── BGSActorEvent.h │ │ ├── BGSAddonNode.h │ │ ├── BGSAimModel.h │ │ ├── BGSAnimationSystemUtils.h │ │ ├── BGSArtObject.h │ │ ├── BGSAssociationType.h │ │ ├── BGSAttachParentArray.h │ │ ├── BGSAttackData.h │ │ ├── BGSAttackDataForm.h │ │ ├── BGSAttackDataMap.h │ │ ├── BGSAttractionRule.h │ │ ├── BGSAudioEffectChain.h │ │ ├── BGSBaseAlias.h │ │ ├── BGSBehaviorGraphModel.h │ │ ├── BGSBehaviorRootData.h │ │ ├── BGSBendableSpline.h │ │ ├── BGSBipedObjectForm.h │ │ ├── BGSBlockBashData.h │ │ ├── BGSBodyPart.h │ │ ├── BGSBodyPartData.h │ │ ├── BGSBodyPartDefs.h │ │ ├── BGSCameraPath.h │ │ ├── BGSCameraShot.h │ │ ├── BGSCharacterMorph.h │ │ ├── BGSCharacterTint.h │ │ ├── BGSCollisionLayer.h │ │ ├── BGSColorForm.h │ │ ├── BGSComponent.h │ │ ├── BGSConstructibleObject.h │ │ ├── BGSCraftItemEvent.h │ │ ├── BGSCraftingUseSound.h │ │ ├── BGSCreatedObjectManager.h │ │ ├── BGSDamageType.h │ │ ├── BGSDebris.h │ │ ├── BGSDefaultObject.h │ │ ├── BGSDefaultObjectManager.h │ │ ├── BGSDestructibleObjectForm.h │ │ ├── BGSDialogueBranch.h │ │ ├── BGSDirectionalAmbientLightingColors.h │ │ ├── BGSDualCastData.h │ │ ├── BGSDualCastDataDEF.h │ │ ├── BGSDynamicPersistenceManager.h │ │ ├── BGSEncounterZone.h │ │ ├── BGSEntryPoint.h │ │ ├── BGSEquipIndex.h │ │ ├── BGSEquipSlot.h │ │ ├── BGSEquipType.h │ │ ├── BGSExplosion.h │ │ ├── BGSExplosionData.h │ │ ├── BGSFeaturedItemMessage.h │ │ ├── BGSFootstep.h │ │ ├── BGSFootstepSet.h │ │ ├── BGSForcedLocRefType.h │ │ ├── BGSGodRays.h │ │ ├── BGSHackTerminal.h │ │ ├── BGSHazard.h │ │ ├── BGSHazardData.h │ │ ├── BGSHeadPart.h │ │ ├── BGSIdleCollection.h │ │ ├── BGSIdleMarker.h │ │ ├── BGSImpactData.h │ │ ├── BGSImpactDataSet.h │ │ ├── BGSInstanceNamingRules.h │ │ ├── BGSInstanceNamingRulesForm.h │ │ ├── BGSInstancedQuestObjective.h │ │ ├── BGSInventoryInterface.h │ │ ├── BGSInventoryItem.h │ │ ├── BGSInventoryItemEvent.h │ │ ├── BGSInventoryList.h │ │ ├── BGSInventoryListEvent.h │ │ ├── BGSKeyword.h │ │ ├── BGSKeywordForm.h │ │ ├── BGSLargeRefData.h │ │ ├── BGSLensFlare.h │ │ ├── BGSLightingTemplate.h │ │ ├── BGSListForm.h │ │ ├── BGSLocalizedString.h │ │ ├── BGSLocation.h │ │ ├── BGSLocationRefType.h │ │ ├── BGSMaterialObject.h │ │ ├── BGSMaterialSwap.h │ │ ├── BGSMaterialType.h │ │ ├── BGSMenuDisplayObject.h │ │ ├── BGSMenuIcon.h │ │ ├── BGSMessage.h │ │ ├── BGSMessageIcon.h │ │ ├── BGSMod.h │ │ ├── BGSModelMaterialSwap.h │ │ ├── BGSMovableStatic.h │ │ ├── BGSMovementType.h │ │ ├── BGSMusicTrackFormWrapper.h │ │ ├── BGSMusicType.h │ │ ├── BGSNativeTerminalForm.h │ │ ├── BGSNavmeshableObject.h │ │ ├── BGSNote.h │ │ ├── BGSNumericIDIndex.h │ │ ├── BGSObjectInstance.h │ │ ├── BGSObjectInstanceExtra.h │ │ ├── BGSOpenCloseForm.h │ │ ├── BGSOutfit.h │ │ ├── BGSOverridePackCollection.h │ │ ├── BGSPackIn.h │ │ ├── BGSPerk.h │ │ ├── BGSPerkRankArray.h │ │ ├── BGSPickLockEvent.h │ │ ├── BGSPickupPutdownSounds.h │ │ ├── BGSPreloadable.h │ │ ├── BGSPreviewTransform.h │ │ ├── BGSPrimitive.h │ │ ├── BGSProjectile.h │ │ ├── BGSProjectileData.h │ │ ├── BGSPropertySheet.h │ │ ├── BGSQuestInstanceText.h │ │ ├── BGSRefAlias.h │ │ ├── BGSRefAliasInstanceData.h │ │ ├── BGSReferenceEffect.h │ │ ├── BGSRelationship.h │ │ ├── BGSReverbParameters.h │ │ ├── BGSSaveLoadManager.h │ │ ├── BGSSaveLoadThread.h │ │ ├── BGSScene.h │ │ ├── BGSSceneAction.h │ │ ├── BGSSceneActionConversationBase.h │ │ ├── BGSSceneActionDialogue.h │ │ ├── BGSSceneActionNPCResponseDialogue.h │ │ ├── BGSSceneActionPackage.h │ │ ├── BGSSceneActionPlayerDialogue.h │ │ ├── BGSSceneActionRadio.h │ │ ├── BGSSceneActionStartScene.h │ │ ├── BGSSceneActionTimer.h │ │ ├── BGSScenePhase.h │ │ ├── BGSShaderParticleGeometryData.h │ │ ├── BGSSkinForm.h │ │ ├── BGSSoundCategory.h │ │ ├── BGSSoundCategorySnapshot.h │ │ ├── BGSSoundDescriptorForm.h │ │ ├── BGSSoundKeywordMapping.h │ │ ├── BGSSoundOutput.h │ │ ├── BGSSoundTagComponent.h │ │ ├── BGSSoundTagSet.h │ │ ├── BGSStaticCollection.h │ │ ├── BGSStoryEventManager.h │ │ ├── BGSStoryManagerBranchNode.h │ │ ├── BGSStoryManagerEventNode.h │ │ ├── BGSStoryManagerNodeBase.h │ │ ├── BGSStoryManagerQuestNode.h │ │ ├── BGSStoryManagerTreeForm.h │ │ ├── BGSStoryManagerTreeVisitor.h │ │ ├── BGSSynchronizedAnimationManager.h │ │ ├── BGSTalkingActivator.h │ │ ├── BGSTerminal.h │ │ ├── BGSTextureModel.h │ │ ├── BGSTextureSet.h │ │ ├── BGSTopicSubtypeUnion.h │ │ ├── BGSTransform.h │ │ ├── BGSTypedFormValuePair.h │ │ ├── BGSTypedKeywordValue.h │ │ ├── BGSVoiceType.h │ │ ├── BGSZoomData.h │ │ ├── BIPED_MODEL.h │ │ ├── BIPED_OBJECT.h │ │ ├── BIPOBJECT.h │ │ ├── BSAnimationGraphEvent.h │ │ ├── BSAnimationGraphManager.h │ │ ├── BSAnimationGraphVariableCache.h │ │ ├── BSAudioCallbacks.h │ │ ├── BSAudioInit.h │ │ ├── BSAudioManager.h │ │ ├── BSAudioUtil.h │ │ ├── BSAwardsSystemUtility.h │ │ ├── BSBTreeFile.h │ │ ├── BSBatchRenderer.h │ │ ├── BSBound.h │ │ ├── BSCRC32.h │ │ ├── BSContainer.h │ │ ├── BSCoreTypes.h │ │ ├── BSCriticalSection.h │ │ ├── BSEventFlag.h │ │ ├── BSExtraData.h │ │ ├── BSFadeNode.h │ │ ├── BSFile.h │ │ ├── BSFixedString.h │ │ ├── BSFlattenedBoneTree.h │ │ ├── BSFurnitureMarker.h │ │ ├── BSGFxDisplayObject.h │ │ ├── BSGFxFunctionBase.h │ │ ├── BSGFxFunctionHandler.h │ │ ├── BSGFxObject.h │ │ ├── BSGFxShaderFXTarget.h │ │ ├── BSGeometry.h │ │ ├── BSGraphics.h │ │ ├── BSHandleRefObject.h │ │ ├── BSIAudioEffectChain.h │ │ ├── BSIMusicTrack.h │ │ ├── BSIMusicType.h │ │ ├── BSIReverbType.h │ │ ├── BSISoundCategory.h │ │ ├── BSISoundDescriptor.h │ │ ├── BSISoundOutputModel.h │ │ ├── BSInputDevice.h │ │ ├── BSInputDeviceManager.h │ │ ├── BSInputEnableLayer.h │ │ ├── BSInputEnableManager.h │ │ ├── BSInputEventReceiver.h │ │ ├── BSInputEventSingleUser.h │ │ ├── BSInputEventUser.h │ │ ├── BSIntrusiveRefCounted.h │ │ ├── BSLensFlareRenderData.h │ │ ├── BSLightingShaderMaterial.h │ │ ├── BSLightingShaderMaterialBase.h │ │ ├── BSLightingShaderProperty.h │ │ ├── BSMTAManager.h │ │ ├── BSMagicShaderParticles.h │ │ ├── BSMaterialObject.h │ │ ├── BSMemStorage.h │ │ ├── BSModelDB.h │ │ ├── BSNavmesh.h │ │ ├── BSNavmeshClosedDoorInfo.h │ │ ├── BSNavmeshCoverEdge.h │ │ ├── BSNavmeshCoverEdgeBase.h │ │ ├── BSNavmeshEdgeExtraInfo.h │ │ ├── BSNavmeshGrid.h │ │ ├── BSNavmeshInfoMap.h │ │ ├── BSNavmeshTriangle.h │ │ ├── BSNavmeshTriangleDoorPortal.h │ │ ├── BSNavmeshTriangleEdgePortal.h │ │ ├── BSNavmeshVertex.h │ │ ├── BSNavmeshWaypoint.h │ │ ├── BSPackedTaskQueue.h │ │ ├── BSPointerAllocator.h │ │ ├── BSPointerHandle.h │ │ ├── BSPreCulledObjects.h │ │ ├── BSPrecomputedNavmeshInfoPathMap.h │ │ ├── BSRandom.h │ │ ├── BSReloadShaderI.h │ │ ├── BSResource.h │ │ ├── BSResourceNiBinaryStream.h │ │ ├── BSResource_Archive2_AsyncReaderStream.h │ │ ├── BSResource_Archive2_ClearRegistryEvent.h │ │ ├── BSResource_Archive2_DataReader.h │ │ ├── BSResource_Archive2_Index.h │ │ ├── BSResource_Archive2_ReaderStream.h │ │ ├── BSResource_Archive2_RegisteredEvent.h │ │ ├── BSResource_Archive2_StreamOpenedEvent.h │ │ ├── BSResource_AsyncStream.h │ │ ├── BSResource_EntryBase.h │ │ ├── BSResource_EntryBucketQueue.h │ │ ├── BSResource_EntryDBBaseUtil.h │ │ ├── BSResource_EntryQueue.h │ │ ├── BSResource_ErrorCode.h │ │ ├── BSResource_FileID.h │ │ ├── BSResource_GlobalLocations.h │ │ ├── BSResource_GlobalPaths.h │ │ ├── BSResource_ICacheDriveOp.h │ │ ├── BSResource_ID.h │ │ ├── BSResource_IEntryDB.h │ │ ├── BSResource_Info.h │ │ ├── BSResource_Location.h │ │ ├── BSResource_LooseFileStreamBase.h │ │ ├── BSResource_SDirectory2.h │ │ ├── BSResource_SeekMode.h │ │ ├── BSResource_Stream.h │ │ ├── BSResource_StreamBase.h │ │ ├── BSSaveDataSystemUtility.h │ │ ├── BSSaveDataSystemUtilityImage.h │ │ ├── BSScaleformExternalTexture.h │ │ ├── BSScaleformManager.h │ │ ├── BSScaleformRenderer.h │ │ ├── BSScaleformTranslator.h │ │ ├── BSScriptUtil.h │ │ ├── BSScript_Array.h │ │ ├── BSScript_ArrayWrapper.h │ │ ├── BSScript_CompiledScriptLoader.h │ │ ├── BSScript_ErrorLogger.h │ │ ├── BSScript_ICachedErrorMessage.h │ │ ├── BSScript_IClientVM.h │ │ ├── BSScript_IComplexType.h │ │ ├── BSScript_IHandleReaderWriter.h │ │ ├── BSScript_ILoader.h │ │ ├── BSScript_IMemoryPagePolicy.h │ │ ├── BSScript_IObjectHandlePolicy.h │ │ ├── BSScript_IObjectProcessor.h │ │ ├── BSScript_ISavePatcherInterface.h │ │ ├── BSScript_IStackCallbackFunctor.h │ │ ├── BSScript_IStackCallbackSaveInterface.h │ │ ├── BSScript_IVMDebugInterface.h │ │ ├── BSScript_IVMObjectBindInterface.h │ │ ├── BSScript_IVirtualMachine.h │ │ ├── BSScript_Internal_AttachedScript.h │ │ ├── BSScript_Internal_CodeTasklet.h │ │ ├── BSScript_Internal_EventRelay.h │ │ ├── BSScript_Internal_FunctionMessage.h │ │ ├── BSScript_Internal_IFuncCallQuery.h │ │ ├── BSScript_Internal_IFunction.h │ │ ├── BSScript_Internal_IProfilePolicy.h │ │ ├── BSScript_Internal_IVMSaveLoadInterface.h │ │ ├── BSScript_Internal_LinkerProcessor.h │ │ ├── BSScript_Internal_NativeFunctionBase.h │ │ ├── BSScript_Internal_RawFuncCallQuery.h │ │ ├── BSScript_Internal_ReadableStringTable.h │ │ ├── BSScript_Internal_ReadableTypeTable.h │ │ ├── BSScript_Internal_ScriptFunction.h │ │ ├── BSScript_Internal_Stack.h │ │ ├── BSScript_Internal_SuspendedStack.h │ │ ├── BSScript_Internal_VDescTable.h │ │ ├── BSScript_Internal_VirtualMachine.h │ │ ├── BSScript_Internal_WritableStringTable.h │ │ ├── BSScript_Internal_WritableTypeTable.h │ │ ├── BSScript_LogEvent.h │ │ ├── BSScript_MergedBoundScript.h │ │ ├── BSScript_Object.h │ │ ├── BSScript_ObjectBindPolicy.h │ │ ├── BSScript_ObjectTypeInfo.h │ │ ├── BSScript_PackedInstructionStream.h │ │ ├── BSScript_PropertyGroupInfo.h │ │ ├── BSScript_PropertyTypeInfo.h │ │ ├── BSScript_SimpleAllocMemoryPagePolicy.h │ │ ├── BSScript_StackFrame.h │ │ ├── BSScript_StatsEvent.h │ │ ├── BSScript_Struct.h │ │ ├── BSScript_StructTypeInfo.h │ │ ├── BSScript_TypeInfo.h │ │ ├── BSScript_Variable.h │ │ ├── BSSemaphore.h │ │ ├── BSShader.h │ │ ├── BSShaderData.h │ │ ├── BSShaderMaterial.h │ │ ├── BSShaderProperty.h │ │ ├── BSShaderPropertyLightData.h │ │ ├── BSShaderTechniqueIDMap.h │ │ ├── BSShaderTextureSet.h │ │ ├── BSSimpleList.h │ │ ├── BSSoundHandle.h │ │ ├── BSSpinLock.h │ │ ├── BSSpring_SpringState.h │ │ ├── BSSteamAwardsSystemUtility.h │ │ ├── BSStorage.h │ │ ├── BSStorageDefs.h │ │ ├── BSStreamHeader.h │ │ ├── BSStringPool.h │ │ ├── BSStringT.h │ │ ├── BSSystemFile.h │ │ ├── BSSystemFileStreamer.h │ │ ├── BSTArray.h │ │ ├── BSTAtomicValue.h │ │ ├── BSTBTree.h │ │ ├── BSTDataBuffer.h │ │ ├── BSTEvent.h │ │ ├── BSTFreeList.h │ │ ├── BSTHashMap.h │ │ ├── BSTInterpolator.h │ │ ├── BSTMessageQueue.h │ │ ├── BSTObjectArena.h │ │ ├── BSTOptional.h │ │ ├── BSTPoint.h │ │ ├── BSTPointerAndFlags.h │ │ ├── BSTSingleton.h │ │ ├── BSTSmallIndexScatterTable.h │ │ ├── BSTSmartPointer.h │ │ ├── BSTTuple.h │ │ ├── BSTempEffect.h │ │ ├── BSTempEffectDebris.h │ │ ├── BSTempEffectGeometryDecal.h │ │ ├── BSTempEffectParticle.h │ │ ├── BSTempEffectSPG.h │ │ ├── BSTempEffectScreenSpaceDecal.h │ │ ├── BSTempEffectUtil.h │ │ ├── BSTempEffectWeaponBlood.h │ │ ├── BSTerrainEffect.h │ │ ├── BSTextureDB.h │ │ ├── BSTextureSet.h │ │ ├── BSTextureStreamer.h │ │ ├── BSThread.h │ │ ├── BSThreadEvent.h │ │ ├── BSTimer.h │ │ ├── BSTransformDeltaEvent.h │ │ ├── BSTranslator.h │ │ ├── BSTriShape.h │ │ ├── BSUIMessageData.h │ │ ├── BSUIScaleformData.h │ │ ├── BSUtilities.h │ │ ├── BSUtilityShader.h │ │ ├── BSVisit.h │ │ ├── BS_BUTTON_CODE.h │ │ ├── BarrierProjectile.h │ │ ├── BarterMenu.h │ │ ├── BarterMenuTentativeInventoryUIInterface.h │ │ ├── BaseBotConfirmCallback.h │ │ ├── BaseExtraList.h │ │ ├── BaseFormComponent.h │ │ ├── BaseLoadedInventoryModel.h │ │ ├── BeamProjectile.h │ │ ├── BipedAnim.h │ │ ├── Bleedout.h │ │ ├── BobbleheadCollected.h │ │ ├── BooksRead.h │ │ ├── ButtonEvent.h │ │ ├── ButtonHintBar.h │ │ ├── bhkCharProxyManager.h │ │ ├── bhkCharRigidBodyManager.h │ │ ├── bhkCharacterController.h │ │ ├── bhkCollisionQueryResultHandle.h │ │ ├── bhkIWorldStepListener.h │ │ ├── bhkNPCollisionObject.h │ │ ├── bhkNPCollisionObjectBase.h │ │ ├── bhkNPCollisionObjectUnlinked.h │ │ ├── bhkPhysicsSystem.h │ │ ├── bhkPickData.h │ │ ├── bhkUtilFunctions.h │ │ ├── bhkWorld.h │ │ └── bhkWorldM.h │ ├── C │ │ ├── CALCED_OBJECT.h │ │ ├── CELLJobs.h │ │ ├── CFilter.h │ │ ├── CHANGE_TYPES.h │ │ ├── CLASS_DATA.h │ │ ├── COMMAND_TYPE.h │ │ ├── COMPILER_NAME.h │ │ ├── CONDITIONITEMOBJECT.h │ │ ├── CONDITION_ITEM_DATA.h │ │ ├── CONT_DATA.h │ │ ├── CachedValueData.h │ │ ├── CachedValues.h │ │ ├── Calendar.h │ │ ├── CameraStates.h │ │ ├── CanDisplayNextHUDMessage.h │ │ ├── CellAttachDetachEvent.h │ │ ├── CellAttachDetachEventSource.h │ │ ├── CharacterEvent.h │ │ ├── ColorUpdateEvent.h │ │ ├── CombatFormulas.h │ │ ├── CombatStyleCloseRangeData.h │ │ ├── CombatStyleCoverData.h │ │ ├── CombatStyleFlightData.h │ │ ├── CombatStyleGeneralData.h │ │ ├── CombatStyleLongRangeData.h │ │ ├── CombatStyleMeleeData.h │ │ ├── CombatStyleRangedData.h │ │ ├── CombatUtilities.h │ │ ├── CommandedActorData.h │ │ ├── ComparisonQualifiers.h │ │ ├── ConcreteFormFactory.h │ │ ├── ConcreteObjectFormFactory.h │ │ ├── ConditionCheckParams.h │ │ ├── ConeProjectile.h │ │ ├── Console.h │ │ ├── ConsoleLog.h │ │ ├── ContainerItemExtra.h │ │ ├── ContainerMenu.h │ │ ├── ContainerMenuBase.h │ │ ├── ContainerObject.h │ │ ├── ControlMap.h │ │ ├── CreatureSounds.h │ │ ├── CrimeGoldStruct.h │ │ ├── CurrentRadiationSourceCount.h │ │ ├── CurrentRadsDisplayMagnitude.h │ │ ├── CurrentRadsPercentOfLethal.h │ │ ├── CursorMenu.h │ │ ├── CursorMoveEvent.h │ │ └── CustomMarkerUpdate.h │ ├── D │ │ ├── DECAL_DATA_DATA.h │ │ ├── DEFAULT_OBJECT.h │ │ ├── DEFAULT_OBJECT_DATA.h │ │ ├── DEFAULT_OBJECT_TYPE.h │ │ ├── DIALOGUE_DATA.h │ │ ├── DIALOGUE_SUBTYPE.h │ │ ├── DIALOGUE_TYPE.h │ │ ├── DIRECTION_VAL.h │ │ ├── DamageImpactData.h │ │ ├── DecalData.h │ │ ├── DefaultObjectFormFactory.h │ │ ├── DestructibleObjectData.h │ │ ├── DestructibleObjectStage.h │ │ ├── DeviceConnectEvent.h │ │ ├── DialogueMenu.h │ │ ├── DialoguePackage.h │ │ ├── DifficultyLevel.h │ │ ├── DisableHeavyItemsFunc.h │ │ ├── DisconnectHandler.h │ │ ├── DisplayItemModel.h │ │ ├── DoBeforeNewOrLoadCompletedEvent.h │ │ └── DoorTeleportData.h │ ├── E │ │ ├── EDGE_EXTRA_INFO_TYPE.h │ │ ├── ENCOUNTER_ZONE_DATA.h │ │ ├── ENCOUNTER_ZONE_GAME_DATA.h │ │ ├── ENUM_COMPARISON_CONDITION.h │ │ ├── ENUM_FORM_ID.h │ │ ├── ENUM_LOD_MULT.h │ │ ├── EQUIP_TYPE.h │ │ ├── EXTRA_DATA_TYPE.h │ │ ├── EaseOutInterpolator.h │ │ ├── EffectArchetypes.h │ │ ├── EffectItem.h │ │ ├── EffectItemData.h │ │ ├── EffectSetting.h │ │ ├── EffectShaderData.h │ │ ├── EnchantmentItem.h │ │ ├── EquipSlotData.h │ │ ├── EquippedItem.h │ │ ├── EquippedItemData.h │ │ ├── EquippedWeaponData.h │ │ ├── ExamineConfirmMenu.h │ │ ├── ExamineMenu.h │ │ ├── Explosion.h │ │ ├── ExteriorCellSingleton.h │ │ ├── ExtraAliasInstanceArray.h │ │ ├── ExtraBendableSplineParams.h │ │ ├── ExtraCellWaterType.h │ │ ├── ExtraCharge.h │ │ ├── ExtraDataList.h │ │ ├── ExtraFavorite.h │ │ ├── ExtraHealth.h │ │ ├── ExtraInstanceData.h │ │ ├── ExtraLeveledCreature.h │ │ ├── ExtraLocation.h │ │ ├── ExtraLock.h │ │ ├── ExtraMapMarker.h │ │ ├── ExtraMaterialSwap.h │ │ ├── ExtraPowerLinks.h │ │ ├── ExtraReferenceHandles.h │ │ ├── ExtraStartingWorldOrCell.h │ │ ├── ExtraTeleport.h │ │ ├── ExtraTextDisplayData.h │ │ └── ExtraUniqueID.h │ ├── F │ │ ├── FACTION_CRIME_DATA.h │ │ ├── FACTION_CRIME_DATA_VALUES.h │ │ ├── FACTION_DATA.h │ │ ├── FACTION_RANK.h │ │ ├── FACTION_VENDOR_DATA.h │ │ ├── FACTION_VENDOR_DATA_VALUES.h │ │ ├── FIGHT_REACTION.h │ │ ├── FILE_HEADER.h │ │ ├── FORM.h │ │ ├── FORM_ENUM_STRING.h │ │ ├── FUNCTION_DATA.h │ │ ├── FatmanDeaths.h │ │ ├── FavoriteMgr_Events.h │ │ ├── FavoritesManager.h │ │ ├── FlameProjectile.h │ │ ├── FlatScreenModel.h │ │ ├── FleePackage.h │ │ ├── FreeCameraState.h │ │ └── FriendshipFactionsStruct.h │ ├── Fallout.h │ ├── G │ │ ├── GROUP_REACTION.h │ │ ├── GUN_STATE.h │ │ ├── GameMenuBase.h │ │ ├── GamePlayFormulas.h │ │ ├── GameScript.h │ │ ├── GameUIModel.h │ │ ├── GetCurrentPositionFunctor.h │ │ ├── GrenadeProjectile.h │ │ ├── GridArray.h │ │ ├── GridCell.h │ │ └── GridCellArray.h │ ├── H │ │ ├── HUDColorTypes.h │ │ ├── HUDMenu.h │ │ ├── HUDMenuUtils.h │ │ ├── HUDModeEvent.h │ │ ├── HUDModeType.h │ │ ├── HUDModes.h │ │ ├── HUDPerkVaultBoyData.h │ │ ├── HUDPerkVaultBoySwfDisplayEvent.h │ │ ├── Hazard.h │ │ ├── HeldStateHandler.h │ │ ├── HitData.h │ │ ├── HolotapeMenu.h │ │ ├── HolotapeStateChanged.h │ │ ├── HourPassed.h │ │ ├── hkAabb.h │ │ ├── hkArray.h │ │ ├── hkBaseObject.h │ │ ├── hkBitField.h │ │ ├── hkBlockStream.h │ │ ├── hkBlockStreamBase.h │ │ ├── hkBool.h │ │ ├── hkContainerHeapAllocator.h │ │ ├── hkCriticalSection.h │ │ ├── hkEnum.h │ │ ├── hkFlags.h │ │ ├── hkHandle.h │ │ ├── hkIntSpaceUtil.h │ │ ├── hkMap.h │ │ ├── hkMemoryAllocator.h │ │ ├── hkPadSpu.h │ │ ├── hkPtrAndInt.h │ │ ├── hkRefPtr.h │ │ ├── hkReferencedObject.h │ │ ├── hkSignal.h │ │ ├── hkSimdFloat32.h │ │ ├── hkSlot.h │ │ ├── hkStepInfo.h │ │ ├── hkVector4f.h │ │ ├── hkcdRay.h │ │ ├── hkcdRayQueryFlags.h │ │ ├── hknpBodyId.h │ │ ├── hknpBodyManager.h │ │ ├── hknpCharacterContext.h │ │ ├── hknpCharacterState.h │ │ ├── hknpCharacterSurfaceInfo.h │ │ ├── hknpCollisionQuery.h │ │ ├── hknpCollisionQueryType.h │ │ ├── hknpCollisionResult.h │ │ ├── hknpConstraintIdDiscriminant.h │ │ ├── hknpConstraintManager.h │ │ ├── hknpContactSolverType.h │ │ ├── hknpMaterialId.h │ │ ├── hknpMotionId.h │ │ ├── hknpMotionManager.h │ │ ├── hknpMotionPropertiesId.h │ │ ├── hknpQueryFilterData.h │ │ ├── hknpRayCastQuery.h │ │ ├── hknpRayCastQueryResult.h │ │ ├── hknpShapeManager.h │ │ ├── hknpShapeSignals.h │ │ ├── hknpSolverInfo.h │ │ ├── hknpThreadSafetyCheck.h │ │ ├── hknpWorld.h │ │ ├── hknpWorldCinfo.h │ │ └── hknpWorldSignals.h │ ├── I │ │ ├── IAnimationGraphManagerHolder.h │ │ ├── IDEvent.h │ │ ├── IDLE_DATA.h │ │ ├── IEventCallback.h │ │ ├── IFormFactory.h │ │ ├── IKeywordFormBase.h │ │ ├── IMemoryHeap.h │ │ ├── IMemoryStore.h │ │ ├── IMemoryStoreBase.h │ │ ├── IMenu.h │ │ ├── IMessageBoxCallback.h │ │ ├── IMovementInterface.h │ │ ├── IMovementPlayerControls.h │ │ ├── IMovementPlayerControlsFilter.h │ │ ├── IMovementState.h │ │ ├── INPUT_DEVICE.h │ │ ├── INPUT_DEVICE_LIGHT_STATE.h │ │ ├── INPUT_EVENT_TYPE.h │ │ ├── INSTANCE_FILTER.h │ │ ├── INTERACTING_STATE.h │ │ ├── INTERIOR_DATA.h │ │ ├── IPipboyThrottledValue.h │ │ ├── IPostAnimationChannelUpdateFunctor.h │ │ ├── ITEM_REMOVE_REASON.h │ │ ├── IUIMessageData.h │ │ ├── ImageSpaceBaseData.h │ │ ├── ImageSpaceData.h │ │ ├── ImageSpaceEffect.h │ │ ├── ImageSpaceEffectBokehDepthOfField.h │ │ ├── ImageSpaceEffectDepthOfField.h │ │ ├── ImageSpaceEffectFullScreenBlur.h │ │ ├── ImageSpaceEffectGetHit.h │ │ ├── ImageSpaceEffectHDR.h │ │ ├── ImageSpaceEffectMotionBlur.h │ │ ├── ImageSpaceEffectOption.h │ │ ├── ImageSpaceEffectPipboyScreen.h │ │ ├── ImageSpaceEffectRadialBlur.h │ │ ├── ImageSpaceEffectTemporalAA.h │ │ ├── ImageSpaceLUTData.h │ │ ├── ImageSpaceManager.h │ │ ├── ImageSpaceModData.h │ │ ├── ImageSpaceModifierFinder.h │ │ ├── ImageSpaceModifierInstance.h │ │ ├── ImageSpaceModifierInstanceDOF.h │ │ ├── ImageSpaceModifierInstanceForm.h │ │ ├── ImageSpaceModifierInstanceRB.h │ │ ├── ImageSpaceModifierInstanceTemp.h │ │ ├── ImageSpaceTexture.h │ │ ├── ImpactResult.h │ │ ├── IngredientItem.h │ │ ├── InputEvent.h │ │ ├── Interface3D.h │ │ ├── Inventory3DManager.h │ │ ├── InventoryInterface.h │ │ ├── InventoryItemDisplayData.h │ │ ├── InventoryUserUIInterface.h │ │ ├── InventoryUserUIInterfaceEntry.h │ │ ├── InventoryUserUIUtils.h │ │ ├── IsPipboyActiveEvent.h │ │ └── ItemCrafted.h │ ├── IDs.h │ ├── IDs_NiRTTI.h │ ├── IDs_RTTI.h │ ├── IDs_VTABLE.h │ ├── J │ │ └── JumpHandler.h │ ├── K │ │ ├── KeywordType.h │ │ └── KinectEvent.h │ ├── L │ │ ├── LEVELED_OBJECT.h │ │ ├── LOADED_CELL_DATA.h │ │ ├── LOADED_REF_DATA.h │ │ ├── LOCK_LEVEL.h │ │ ├── LevelIncrease.h │ │ ├── LoadingMenu.h │ │ ├── LoadingStatusChanged.h │ │ ├── LocalMapCameraUpdate.h │ │ ├── LocationMarkerArrayUpdate.h │ │ ├── LockpickingMenu.h │ │ ├── LocksPicked.h │ │ └── LookHandler.h │ ├── M │ │ ├── MELEE_ATTACK_SPEED.h │ │ ├── MENU_RENDER_CONTEXT.h │ │ ├── MESSAGEBOX_BUTTON.h │ │ ├── MOVABLE_STATIC_DATA.h │ │ ├── MagicItem.h │ │ ├── MagicTarget.h │ │ ├── Main.h │ │ ├── MapMarkerData.h │ │ ├── MeleeThrowHandler.h │ │ ├── MemoryManager.h │ │ ├── MenuControls.h │ │ ├── MenuCursor.h │ │ ├── MenuModeChangeEvent.h │ │ ├── MenuModeCounterChangedEvent.h │ │ ├── MenuOpenCloseEvent.h │ │ ├── MenuOpenHandler.h │ │ ├── MenuTopicManager.h │ │ ├── MessageBoxData.h │ │ ├── MessageBoxMenu.h │ │ ├── MessageMenuManager.h │ │ ├── MiddleHighProcessData.h │ │ ├── MiddleLowProcessData.h │ │ ├── MissileProjectile.h │ │ ├── ModConfirmCallback.h │ │ ├── ModelReferenceEffect.h │ │ ├── Modifiers.h │ │ ├── MouseMoveEvent.h │ │ ├── Movement.h │ │ └── MovementData.h │ ├── N │ │ ├── NEW_REFR_DATA.h │ │ ├── NPC_DATA.h │ │ ├── NavMesh.h │ │ ├── NavMeshInfoMap.h │ │ ├── NiAVObject.h │ │ ├── NiAlphaProperty.h │ │ ├── NiBinaryStream.h │ │ ├── NiBound.h │ │ ├── NiCamera.h │ │ ├── NiCloningProcess.h │ │ ├── NiCollisionObject.h │ │ ├── NiColor.h │ │ ├── NiControllerManager.h │ │ ├── NiControllerSequence.h │ │ ├── NiExtraData.h │ │ ├── NiExtraDataContainer.h │ │ ├── NiFile.h │ │ ├── NiFrustum.h │ │ ├── NiMatrix3.h │ │ ├── NiMemManager.h │ │ ├── NiMemStream.h │ │ ├── NiNPShortPoint3.h │ │ ├── NiNode.h │ │ ├── NiObject.h │ │ ├── NiObjectNET.h │ │ ├── NiPoint.h │ │ ├── NiPointer.h │ │ ├── NiProperty.h │ │ ├── NiQuaternion.h │ │ ├── NiRTTI.h │ │ ├── NiRect.h │ │ ├── NiRefObject.h │ │ ├── NiShadeProperty.h │ │ ├── NiStream.h │ │ ├── NiStringExtraData.h │ │ ├── NiTArray.h │ │ ├── NiTDefaultAllocator.h │ │ ├── NiTFlags.h │ │ ├── NiTLargeArray.h │ │ ├── NiTList.h │ │ ├── NiTMap.h │ │ ├── NiTPointerAllocator.h │ │ ├── NiTPointerMap.h │ │ ├── NiTexture.h │ │ ├── NiTimeController.h │ │ ├── NiTransform.h │ │ ├── NiUpdateData.h │ │ └── nsStatsMenuUtils.h │ ├── O │ │ ├── OBJ_ARMA.h │ │ ├── OBJ_BOOK.h │ │ ├── OBJ_LAND.h │ │ ├── OBJ_LIGH.h │ │ ├── OBJ_REFR.h │ │ ├── OBJ_TREE.h │ │ └── OtherInputEvents.h │ ├── P │ │ ├── PACKAGE_DATA.h │ │ ├── PACKAGE_OBJECT_TYPE.h │ │ ├── PACK_SCHED_DATA.h │ │ ├── PART_DATA.h │ │ ├── PATH_DATA.h │ │ ├── PC_GAMEPAD_TYPE.h │ │ ├── PIPBOY_PAGES.h │ │ ├── PLAYER_ACTION.h │ │ ├── PLAYER_TARGET_LOC.h │ │ ├── POWER_ARMOR_HUD_VISIBILITY_RULE.h │ │ ├── PTYPE.h │ │ ├── PackageEventAction.h │ │ ├── PackageList.h │ │ ├── PackageSchedule.h │ │ ├── PauseMenu.h │ │ ├── PerkAdded.h │ │ ├── PerkData.h │ │ ├── PerkPointIncreaseEvent.h │ │ ├── PerkRankData.h │ │ ├── PerkUtilities.h │ │ ├── PerkValueEvents.h │ │ ├── PersistentPassList.h │ │ ├── PipboyArray.h │ │ ├── PipboyDataGroup.h │ │ ├── PipboyDataManager.h │ │ ├── PipboyHolotapeMenu.h │ │ ├── PipboyInventoryData.h │ │ ├── PipboyInventoryMenu.h │ │ ├── PipboyInventoryUtils.h │ │ ├── PipboyLightEvent.h │ │ ├── PipboyLogData.h │ │ ├── PipboyLogMenu.h │ │ ├── PipboyManager.h │ │ ├── PipboyMapData.h │ │ ├── PipboyMapMenu.h │ │ ├── PipboyMenu.h │ │ ├── PipboyObject.h │ │ ├── PipboyPerksData.h │ │ ├── PipboyPerksMenu.h │ │ ├── PipboyPlayerInfoData.h │ │ ├── PipboyPlayerInfoMenu.h │ │ ├── PipboyPrimitiveValue.h │ │ ├── PipboyQuestData.h │ │ ├── PipboyQuestMenu.h │ │ ├── PipboyRadioController.h │ │ ├── PipboyRadioData.h │ │ ├── PipboyRadioMenu.h │ │ ├── PipboySpecialData.h │ │ ├── PipboySpecialMenu.h │ │ ├── PipboyStatsData.h │ │ ├── PipboyStatsMenu.h │ │ ├── PipboyStatusData.h │ │ ├── PipboySubMenu.h │ │ ├── PipboyThrottleManager.h │ │ ├── PipboyValue.h │ │ ├── PipboyWorkshopData.h │ │ ├── PipboyWorkshopMenu.h │ │ ├── PlayerActiveEffectChanged.h │ │ ├── PlayerAddicted.h │ │ ├── PlayerAmmoCountEvent.h │ │ ├── PlayerAmmoCounts.h │ │ ├── PlayerAutoAimActorEvent.h │ │ ├── PlayerCamera.h │ │ ├── PlayerCharacter.h │ │ ├── PlayerCharacterQuestEvent.h │ │ ├── PlayerCommandTypeEvent.h │ │ ├── PlayerControls.h │ │ ├── PlayerControlsData.h │ │ ├── PlayerControlsMovementData.h │ │ ├── PlayerCoverData.h │ │ ├── PlayerDifficultySettingChanged.h │ │ ├── PlayerInDialogueChanged.h │ │ ├── PlayerInputHandler.h │ │ ├── PlayerLifeStateChanged.h │ │ ├── PlayerUpdateEvent.h │ │ ├── PlayerWeaponReloadEvent.h │ │ ├── PositionPlayerEvent.h │ │ ├── PowerArmor.h │ │ ├── PowerArmorGeometry.h │ │ ├── PowerArmorLightData.h │ │ ├── PowerArmorModMenu.h │ │ ├── PowerUtils.h │ │ ├── PrecomputedNavmeshInfoPathMap.h │ │ ├── ProcessLists.h │ │ ├── Projectile.h │ │ └── ProjectileLaunchData.h │ ├── Q │ │ ├── QUEST_DATA.h │ │ ├── QUEST_OBJECTIVE_STATE.h │ │ ├── QuickContainerMode.h │ │ ├── QuickContainerStateData.h │ │ └── QuickContainerStateEvent.h │ ├── R │ │ ├── RACE_DATA.h │ │ ├── RACE_SIZE.h │ │ ├── RANK_DATA.h │ │ ├── REFR_LOCK.h │ │ ├── RESET_3D_FLAGS.h │ │ ├── ReadyWeaponHandler.h │ │ ├── RefAttachTechniqueInput.h │ │ ├── ReferenceEffect.h │ │ ├── ReferenceEffectController.h │ │ ├── RepairFailureCallback.h │ │ ├── RepeaterData.h │ │ ├── ResponseListWrapper.h │ │ └── Rumble.h │ ├── RTTI.h │ ├── S │ │ ├── SCRIPT_EFFECT_DATA.h │ │ ├── SCRIPT_FUNCTION.h │ │ ├── SCRIPT_HEADER.h │ │ ├── SCRIPT_LINE.h │ │ ├── SCRIPT_LOCAL.h │ │ ├── SCRIPT_OUTPUT.h │ │ ├── SCRIPT_PARAMETER.h │ │ ├── SCRIPT_PARAM_TYPE.h │ │ ├── SCRIPT_REFERENCED_OBJECT.h │ │ ├── SEX.h │ │ ├── SFRendererInitializedEvent.h │ │ ├── SIT_SLEEP_STATE.h │ │ ├── SOUND_LEVEL.h │ │ ├── SPECIALMenuEvent.h │ │ ├── SWFToCodeFunctionHandler.h │ │ ├── SayOnceTimeStampStruct.h │ │ ├── ScrapHeap.h │ │ ├── ScrapItemCallback.h │ │ ├── ScreenshotHandler.h │ │ ├── Script.h │ │ ├── ScriptCompileData.h │ │ ├── ScriptCompiler.h │ │ ├── ScriptLocals.h │ │ ├── ScriptVariable.h │ │ ├── ScrollItem.h │ │ ├── SendHUDMessage.h │ │ ├── SetCullMarkersFunctor.h │ │ ├── Setting.h │ │ ├── ShaderReferenceEffect.h │ │ ├── ShowingDialogueSpeechChallengeAnim.h │ │ ├── SimpleAnimationGraphManagerHolder.h │ │ ├── SitWaitMenu.h │ │ ├── Sky.h │ │ ├── SkyEffectController.h │ │ ├── SneakHandler.h │ │ ├── SpecialRefData.h │ │ ├── SpectatorPackage.h │ │ ├── SpectatorThreatInfo.h │ │ ├── SpellItem.h │ │ ├── SplineUtils.h │ │ ├── StartMenuBase.h │ │ ├── StolenItemValueStruct.h │ │ ├── SubGraphIdleRootData.h │ │ ├── SubgraphHandle.h │ │ ├── SubgraphIdentifier.h │ │ └── SummonPlacementEffect.h │ ├── T │ │ ├── TBO_InstanceData.h │ │ ├── TEMP_EFFECT_TYPE.h │ │ ├── TES.h │ │ ├── TESAIForm.h │ │ ├── TESActivateEvent.h │ │ ├── TESActorBase.h │ │ ├── TESActorBaseData.h │ │ ├── TESAmmo.h │ │ ├── TESBipedModelForm.h │ │ ├── TESBoundAnimObject.h │ │ ├── TESBoundObject.h │ │ ├── TESCamera.h │ │ ├── TESCameraState.h │ │ ├── TESCellAttachDetachEvent.h │ │ ├── TESCellFullyLoadedEvent.h │ │ ├── TESChildCell.h │ │ ├── TESClass.h │ │ ├── TESClimate.h │ │ ├── TESCombatStyle.h │ │ ├── TESCondition.h │ │ ├── TESConditionItem.h │ │ ├── TESContainer.h │ │ ├── TESContainerChangedEvent.h │ │ ├── TESDataHandler.h │ │ ├── TESDeathEvent.h │ │ ├── TESDescription.h │ │ ├── TESEffectShader.h │ │ ├── TESEnchantableForm.h │ │ ├── TESEnterSneakingEvent.h │ │ ├── TESEquipEvent.h │ │ ├── TESEyes.h │ │ ├── TESFaction.h │ │ ├── TESFile.h │ │ ├── TESFileArray.h │ │ ├── TESFileCollection.h │ │ ├── TESFileContainer.h │ │ ├── TESFlora.h │ │ ├── TESForm.h │ │ ├── TESFormDeleteEvent.h │ │ ├── TESFormUtil.h │ │ ├── TESFullName.h │ │ ├── TESFurniture.h │ │ ├── TESFurnitureEvent.h │ │ ├── TESGlobal.h │ │ ├── TESGrass.h │ │ ├── TESHarvestEvent.h │ │ ├── TESHealthForm.h │ │ ├── TESHitEvent.h │ │ ├── TESIcon.h │ │ ├── TESIdleForm.h │ │ ├── TESImageSpace.h │ │ ├── TESImageSpaceModifiableForm.h │ │ ├── TESImageSpaceModifier.h │ │ ├── TESInitScriptEvent.h │ │ ├── TESKey.h │ │ ├── TESLandTexture.h │ │ ├── TESLevCharacter.h │ │ ├── TESLevItem.h │ │ ├── TESLevSpell.h │ │ ├── TESLeveledList.h │ │ ├── TESLoadGameEvent.h │ │ ├── TESLoadScreen.h │ │ ├── TESLocationClearedEvent.h │ │ ├── TESMagicCasterForm.h │ │ ├── TESMagicEffectApplyEvent.h │ │ ├── TESMagicTargetForm.h │ │ ├── TESModel.h │ │ ├── TESModelRDT.h │ │ ├── TESModelTri.h │ │ ├── TESNPC.h │ │ ├── TESObject.h │ │ ├── TESObjectACTI.h │ │ ├── TESObjectANIO.h │ │ ├── TESObjectARMA.h │ │ ├── TESObjectARMO.h │ │ ├── TESObjectBOOK.h │ │ ├── TESObjectCELL.h │ │ ├── TESObjectCONT.h │ │ ├── TESObjectDOOR.h │ │ ├── TESObjectLAND.h │ │ ├── TESObjectLIGH.h │ │ ├── TESObjectLoadedEvent.h │ │ ├── TESObjectMISC.h │ │ ├── TESObjectREFR.h │ │ ├── TESObjectSTAT.h │ │ ├── TESObjectSTATData.h │ │ ├── TESObjectTREE.h │ │ ├── TESObjectWEAP.h │ │ ├── TESPackage.h │ │ ├── TESProduceForm.h │ │ ├── TESQuest.h │ │ ├── TESQuestEvent.h │ │ ├── TESRace.h │ │ ├── TESRaceForm.h │ │ ├── TESReactionForm.h │ │ ├── TESRegion.h │ │ ├── TESRegionList.h │ │ ├── TESResponse.h │ │ ├── TESShout.h │ │ ├── TESSoulGem.h │ │ ├── TESSound.h │ │ ├── TESSpellList.h │ │ ├── TESSwitchRaceCompleteEvent.h │ │ ├── TESTexture.h │ │ ├── TESTexture1024.h │ │ ├── TESTopic.h │ │ ├── TESTopicInfo.h │ │ ├── TESTrackedStatsEvent.h │ │ ├── TESValueForm.h │ │ ├── TESWaterForm.h │ │ ├── TESWeather.h │ │ ├── TESWeatherList.h │ │ ├── TESWeightForm.h │ │ ├── TESWordOfPower.h │ │ ├── TESWorldSpace.h │ │ ├── TEXTURE_HAVOK_DATA.h │ │ ├── TLS.h │ │ ├── TOPIC_INFO_DATA.h │ │ ├── TOPIC_INFO_SCENEDATA.h │ │ ├── TaskQueueInterface.h │ │ ├── TerminalHacked.h │ │ ├── TerminalHolotapeMenu.h │ │ ├── TerminalMenu.h │ │ ├── TerminalMenuButtons.h │ │ ├── ThirdPersonState.h │ │ ├── ThumbstickEvent.h │ │ ├── TravelMarkerStateChange.h │ │ ├── TrespassPackage.h │ │ └── TutorialEvent.h │ ├── U │ │ ├── UI.h │ │ ├── UIAdvanceMenusFunctionCompleteEvent.h │ │ ├── UIMenuEntry.h │ │ ├── UIMessage.h │ │ ├── UIMessageQueue.h │ │ ├── UIShaderColors.h │ │ ├── UIShaderFXInfo.h │ │ ├── UIUtils.h │ │ ├── UI_DEPTH_PRIORITY.h │ │ ├── UI_MENU_FLAGS.h │ │ ├── UI_MESSAGE_RESULTS.h │ │ ├── UI_MESSAGE_TYPE.h │ │ ├── UniqueNPCData.h │ │ ├── UnloadedRefData.h │ │ ├── UserEventEnabledEvent.h │ │ ├── UserEvents.h │ │ └── UsesBSGFXFunctionHandler.h │ ├── V │ │ ├── VATS.h │ │ ├── VATSEvents.h │ │ └── VOICE_TYPE_DATA.h │ ├── W │ │ ├── WARNING_TYPES.h │ │ ├── WEAPONHITBEHAVIOR.h │ │ ├── WEAPON_CULL_TYPE.h │ │ ├── WEAPON_FLAGS.h │ │ ├── WEAPON_RUMBLE_PATTERN.h │ │ ├── WEAPON_STATE.h │ │ ├── WEAPON_TYPE.h │ │ ├── WORLD_MAP_DATA.h │ │ ├── WORLD_MAP_OFFSET_DATA.h │ │ ├── WaterShaderData.h │ │ ├── WeaponAnimationGraphManagerHolder.h │ │ ├── WeatherEntry.h │ │ ├── WorkbenchData.h │ │ ├── WorkbenchMenuBase.h │ │ ├── Workshop.h │ │ └── WorkshopMenu.h │ └── X │ │ └── XPChangeData.h └── Scaleform │ ├── A │ ├── AcquireInterface.h │ ├── AllocInfo.h │ ├── Allocator.h │ ├── Array.h │ ├── ArrayPaged.h │ ├── Atomic.h │ └── AutoPtr.h │ ├── E │ └── Event.h │ ├── F │ └── Flags.h │ ├── G │ ├── GFx_AS3_ASVM.h │ ├── GFx_AS3_Abc_ClassTable.h │ ├── GFx_AS3_Abc_ConstPool.h │ ├── GFx_AS3_Abc_File.h │ ├── GFx_AS3_Abc_MbiInd.h │ ├── GFx_AS3_Abc_MetadataTable.h │ ├── GFx_AS3_Abc_MethodBodyTable.h │ ├── GFx_AS3_Abc_MethodTable.h │ ├── GFx_AS3_Abc_NamespaceInfo.h │ ├── GFx_AS3_Abc_NamespaceKind.h │ ├── GFx_AS3_Abc_ScriptTable.h │ ├── GFx_AS3_Abc_TraitTable.h │ ├── GFx_AS3_CallFrame.h │ ├── GFx_AS3_FlashUI.h │ ├── GFx_AS3_GASRefCountBase.h │ ├── GFx_AS3_MovieRoot.h │ ├── GFx_AS3_RefCountBaseGC.h │ ├── GFx_AS3_SPtr.h │ ├── GFx_AS3_StringManager.h │ ├── GFx_AS3_TypeInfo.h │ ├── GFx_AS3_VM.h │ ├── GFx_AS3_VMAbcFile.h │ ├── GFx_AS3_VMFile.h │ ├── GFx_AS3_Value.h │ ├── GFx_ASConstString.h │ ├── GFx_ASIntervalTimerIntf.h │ ├── GFx_ASMovieRootBase.h │ ├── GFx_ASString.h │ ├── GFx_ASStringBuiltinManagerT.h │ ├── GFx_ASStringManager.h │ ├── GFx_ASStringNode.h │ ├── GFx_ASStringNodeHolder.h │ ├── GFx_ActionControl.h │ ├── GFx_ExporterInfo.h │ ├── GFx_ExternalInterface.h │ ├── GFx_ExternalLibPtr.h │ ├── GFx_FSCommandHandler.h │ ├── GFx_FileTypeConstants.h │ ├── GFx_FocusGroupDescr.h │ ├── GFx_FocusMovedType.h │ ├── GFx_FunctionHandler.h │ ├── GFx_HeapId.h │ ├── GFx_KeyboardState.h │ ├── GFx_Loader.h │ ├── GFx_LogBase.h │ ├── GFx_LogState.h │ ├── GFx_MemoryContext.h │ ├── GFx_MemoryParams.h │ ├── GFx_Movie.h │ ├── GFx_MovieDef.h │ ├── GFx_MovieImpl.h │ ├── GFx_MultitouchInterface.h │ ├── GFx_PlayState.h │ ├── GFx_Resource.h │ ├── GFx_ResourceId.h │ ├── GFx_ResourceKey.h │ ├── GFx_ResourceLibBase.h │ ├── GFx_StatAmp.h │ ├── GFx_StatFontCache.h │ ├── GFx_StatGroup.h │ ├── GFx_StatIME.h │ ├── GFx_StatMovieData.h │ ├── GFx_StatMovieView.h │ ├── GFx_State.h │ ├── GFx_StateBag.h │ ├── GFx_System.h │ ├── GFx_Translator.h │ ├── GFx_UserEventHandler.h │ ├── GFx_Value.h │ └── GFx_Viewport.h │ ├── L │ ├── List.h │ ├── Lock.h │ ├── Log.h │ └── LogMessageId.h │ ├── M │ ├── Memory.h │ ├── MemoryHeap.h │ └── Mutex.h │ ├── N │ └── NewOverrideBase.h │ ├── P │ └── Ptr.h │ ├── R │ ├── RefCountBase.h │ ├── Render_Color.h │ ├── Render_ContextImpl_Context.h │ ├── Render_ContextImpl_ContextCaptureNotify.h │ ├── Render_ContextImpl_ContextData_ImplMixin.h │ ├── Render_ContextImpl_ContextLock.h │ ├── Render_ContextImpl_DisplayHandle.h │ ├── Render_ContextImpl_Entry.h │ ├── Render_ContextImpl_EntryChange.h │ ├── Render_ContextImpl_EntryData.h │ ├── Render_ContextImpl_EntryListAccessor.h │ ├── Render_ContextImpl_EntryPage.h │ ├── Render_ContextImpl_EntryPageBase.h │ ├── Render_ContextImpl_EntryTable.h │ ├── Render_ContextImpl_RTHandle.h │ ├── Render_ContextImpl_RenderNotify.h │ ├── Render_ContextImpl_SnapshotPage.h │ ├── Render_EdgeAAMode.h │ ├── Render_Interfaces.h │ ├── Render_LinearHeap.h │ ├── Render_Matrix.h │ ├── Render_PagedItemBuffer.h │ ├── Render_Point.h │ ├── Render_Rect.h │ ├── Render_ScreenToWorld.h │ ├── Render_ThreadCommand.h │ ├── Render_ThreadCommandQueue.h │ ├── Render_TreeContainer.h │ ├── Render_TreeNode.h │ ├── Render_TreeRoot.h │ ├── Render_TreeShape.h │ └── Render_Viewport.h │ ├── S │ ├── StatBag.h │ ├── StatBasicValues.h │ ├── String.h │ ├── StringDataPtr.h │ ├── SysAlloc.h │ └── System.h │ ├── Scaleform.h │ ├── T │ └── ThreadId.h │ └── W │ ├── WaitCondition.h │ └── Waitable.h ├── res ├── commonlibf4.natvis └── scripts │ └── generate_headers.py ├── src ├── F4SE │ ├── API.cpp │ ├── Impl │ │ └── PCH.cpp │ ├── InputMap.cpp │ └── Interfaces.cpp ├── RE │ ├── A │ │ └── Actor.cpp │ ├── B │ │ ├── BGSCreatedObjectManager.cpp │ │ ├── BGSInventoryItem.cpp │ │ ├── BGSKeyword.cpp │ │ ├── BGSKeywordForm.cpp │ │ ├── BGSLocation.cpp │ │ ├── BGSObjectInstanceExtra.cpp │ │ ├── BSCRC32.cpp │ │ ├── BSFixedString.cpp │ │ ├── BSPointerHandle.cpp │ │ ├── BSResource.cpp │ │ ├── BSResourceNiBinaryStream.cpp │ │ ├── BSResource_Stream.cpp │ │ ├── BSResource_StreamBase.cpp │ │ ├── BSScaleformManager.cpp │ │ ├── BSScript_Array.cpp │ │ ├── BSScript_Internal_VirtualMachine.cpp │ │ ├── BSScript_Object.cpp │ │ ├── BSScript_ObjectTypeInfo.cpp │ │ ├── BSScript_PackedInstructionStream.cpp │ │ ├── BSScript_StackFrame.cpp │ │ ├── BSScript_Struct.cpp │ │ ├── BSScript_StructTypeInfo.cpp │ │ ├── BSScript_TypeInfo.cpp │ │ ├── BSScript_Variable.cpp │ │ ├── BSSpinLock.cpp │ │ ├── BSSpring_SpringState.cpp │ │ ├── BSTArray.cpp │ │ ├── BSTAtomicValue.cpp │ │ ├── BSTDataBuffer.cpp │ │ ├── BSTInterpolator.cpp │ │ ├── BSTPoint.cpp │ │ ├── BSVisit.cpp │ │ └── ButtonEvent.cpp │ ├── C │ │ ├── Calendar.cpp │ │ ├── CharacterEvent.cpp │ │ └── CursorMoveEvent.cpp │ ├── D │ │ └── DeviceConnectEvent.cpp │ ├── E │ │ └── ExtraInstanceData.cpp │ ├── Fallout.cpp │ ├── G │ │ └── GetCurrentPositionFunctor.cpp │ ├── I │ │ ├── IDEvent.cpp │ │ └── InventoryInterface.cpp │ ├── K │ │ └── KinectEvent.cpp │ ├── M │ │ ├── MenuCursor.cpp │ │ └── MouseMoveEvent.cpp │ ├── N │ │ ├── NiAVObject.cpp │ │ ├── NiBinaryStream.cpp │ │ ├── NiMatrix3.cpp │ │ ├── NiObjectNET.cpp │ │ ├── NiPoint.cpp │ │ ├── NiRect.cpp │ │ └── NiTransform.cpp │ ├── P │ │ └── PlayerCharacter.cpp │ ├── S │ │ └── Setting.cpp │ ├── T │ │ ├── TESFullName.cpp │ │ ├── TESNPC.cpp │ │ ├── TESObjectCELL.cpp │ │ ├── TESValueForm.cpp │ │ └── ThumbstickEvent.cpp │ └── W │ │ └── WorkbenchMenuBase.cpp └── Scaleform │ ├── G │ └── GFx_Movie.cpp │ └── Scaleform.cpp ├── xmake-rules.lua └── xmake.lua /.editorconfig: -------------------------------------------------------------------------------- 1 | [*] 2 | charset = utf-8 3 | insert_final_newline = true 4 | 5 | [*.{h,hpp,hxx,c,cpp,cxx}] 6 | indent_style = tab 7 | indent_size = 4 8 | 9 | [*.cmake] 10 | indent_style = tab 11 | indent_size = 4 12 | 13 | [*.json] 14 | indent_style = space 15 | indent_size = 2 16 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | *.h linguist-language=C++ 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # dot folders 2 | .idea*/ 3 | .vs*/ 4 | .vscode/ 5 | .xmake/ 6 | 7 | # folders 8 | build*/ 9 | cmake-build*/ 10 | out*/ 11 | vs*/ 12 | 13 | # files 14 | *.zip 15 | CMakeUserPresets.json 16 | -------------------------------------------------------------------------------- /include/F4SE/F4SE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "F4SE/Impl/PCH.h" 4 | 5 | #include "F4SE/API.h" 6 | #include "F4SE/InputMap.h" 7 | #include "F4SE/Interfaces.h" 8 | #include "F4SE/Trampoline.h" 9 | #include "F4SE/Version.h" 10 | -------------------------------------------------------------------------------- /include/F4SE/Impl/PCH.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace F4SE 7 | { 8 | using namespace std::literals; 9 | } 10 | 11 | namespace RE 12 | { 13 | using namespace std::literals; 14 | } 15 | 16 | namespace Scaleform 17 | { 18 | using namespace std::literals; 19 | } 20 | 21 | #include "RE/IDs.h" 22 | #include "RE/IDs_NiRTTI.h" 23 | #include "RE/IDs_RTTI.h" 24 | #include "RE/IDs_VTABLE.h" 25 | 26 | #include "RE/B/BSCoreTypes.h" 27 | -------------------------------------------------------------------------------- /include/F4SE/Trampoline.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "REL/Trampoline.h" 4 | 5 | namespace F4SE 6 | { 7 | using Trampoline = REL::Trampoline; 8 | 9 | // DEPRECATED 10 | [[nodiscard]] REL::Trampoline& GetTrampoline() noexcept 11 | { 12 | return REL::GetTrampoline(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/A/ACTION_OBJECT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class ACTION_OBJECT 6 | { 7 | public: 8 | // members 9 | TESForm* form; // 00 10 | std::uint32_t flags; // 08 11 | }; 12 | static_assert(sizeof(ACTION_OBJECT) == 0x10); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/A/ACTOR_CRITICAL_STAGE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_CRITICAL_STAGE : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kGooStart = 0x1, 9 | kGooEnd = 0x2, 10 | kDisintegrateStart = 0x3, 11 | kDisintegrateEnd = 0x4, 12 | kFreezeStart = 0x5, 13 | kFreezeEnd = 0x6, 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/A/ACTOR_LIFE_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_LIFE_STATE : std::int32_t 6 | { 7 | kAlive = 0x0, 8 | kDying = 0x1, 9 | kDead = 0x2, 10 | kUnconscious = 0x3, 11 | kReanimate = 0x4, 12 | kRecycle = 0x5, 13 | kRestrained = 0x6, 14 | kEssentialDown = 0x7, 15 | kBleedout = 0x8 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/A/ACTOR_LOS_LOCATION.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_LOS_LOCATION : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kEye = 0x1, 9 | kHead = 0x2, 10 | kTorse = 0x3, 11 | kFeet = 0x4, 12 | kCount = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/A/ACTOR_VALUE_MODIFIER.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_VALUE_MODIFIER : std::int32_t 6 | { 7 | kPermanent = 0, 8 | kTemporary = 1, 9 | kDamage = 2 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/A/ACTOR_VISIBILITY_MASK.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_VISIBILITY_MASK : std::uint32_t 6 | { 7 | kFrustrum = 1 << 0, 8 | kOcclusion = 1 << 1, 9 | kFaded = 1 << 2, 10 | kAll = kFrustrum | kOcclusion | kFaded, 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/A/ADDON_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class ADDON_DATA 6 | { 7 | public: 8 | // members 9 | std::uint16_t masterParticleCap; // 0 10 | std::int8_t flags; // 2 11 | }; 12 | static_assert(sizeof(ADDON_DATA) == 0x4); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/A/AITimeStamp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class AITimeStamp 6 | { 7 | public: 8 | // members 9 | float timeStamp; // 0 10 | }; 11 | static_assert(sizeof(AITimeStamp) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/A/AITimer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class AITimer 6 | { 7 | public: 8 | float startTime; // 0 9 | float targetTime; // 4 10 | }; 11 | static_assert(sizeof(AITimer) == 0x8); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/A/AMMO_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class AMMO_DATA 6 | { 7 | public: 8 | // members 9 | BGSProjectile* projectile; // 00 10 | std::uint32_t health; // 08 11 | std::int8_t flags; // 0C 12 | float damage; // 10 13 | }; 14 | static_assert(sizeof(AMMO_DATA) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/A/ActiveEffectList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | #include "RE/B/BSTSmartPointer.h" 5 | 6 | namespace RE 7 | { 8 | class ActiveEffectList 9 | { 10 | public: 11 | // members 12 | BSTArray> data; // 00 13 | std::int8_t iterating; // 18 14 | }; 15 | static_assert(sizeof(ActiveEffectList) == 0x20); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/A/ActorItemEquipped.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace ActorItemEquipped 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | const TESBoundObject* item; // 00 12 | const Actor* equipper; // 08 13 | }; 14 | static_assert(sizeof(Event) == 0x10); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/A/ActorKill.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace ActorKill 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | const Actor* killer; 12 | const Actor* victim; 13 | }; 14 | static_assert(sizeof(Event) == 0x10); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/A/ActorValueEvents.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace ActorValueEvents 6 | { 7 | class ActorValueChangedEvent 8 | { 9 | public: 10 | // members 11 | const ActorValueInfo& actorValue; // 00 12 | TESObjectREFR* owner; // 08 13 | }; 14 | static_assert(sizeof(ActorValueChangedEvent) == 0x10); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/A/AnimationStanceNodeLocationData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class AnimationStanceNodeLocationData 7 | { 8 | public: 9 | // members 10 | T nodeLocationArray[3]; // 00 11 | }; 12 | static_assert(sizeof(AnimationStanceNodeLocationData) == 0x18); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/A/AnimationSystemUtils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | namespace AnimationSystemUtils 8 | { 9 | inline bool WillEventChangeState(const TESObjectREFR& a_ref, const BSFixedString& a_evn) 10 | { 11 | using func_t = decltype(&WillEventChangeState); 12 | static REL::Relocation func{ ID::AnimationSystemUtils::WillEventChangeState }; 13 | return func(a_ref, a_evn); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/A/ArrowProjectile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/M/MissileProjectile.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ArrowProjectile : 8 | public MissileProjectile // 000 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ArrowProjectile }; 12 | static constexpr auto VTABLE{ VTABLE::ArrowProjectile }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kPARW }; 14 | 15 | // members 16 | AlchemyItem* poison; // 2C0 17 | }; 18 | static_assert(sizeof(ArrowProjectile) == 0x2D0); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/A/AutoMoveHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/P/PlayerInputHandler.h" 4 | 5 | namespace RE 6 | { 7 | class AutoMoveHandler : 8 | public PlayerInputHandler 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::AutoMoveHandler }; 12 | static constexpr auto VTABLE{ VTABLE::AutoMoveHandler }; 13 | 14 | explicit constexpr AutoMoveHandler(PlayerControlsData& a_data) noexcept : 15 | PlayerInputHandler(a_data) 16 | {} 17 | }; 18 | static_assert(sizeof(AutoMoveHandler) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BGSAction.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSKeyword.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSAction : 8 | public BGSKeyword // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSAction }; 12 | static constexpr auto VTABLE{ VTABLE::BGSAction }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kAACT }; 14 | 15 | // members 16 | std::uint32_t index; // 28 17 | }; 18 | static_assert(sizeof(BGSAction) == 0x30); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BGSActorCellEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSActorEvent.h" 4 | 5 | namespace RE 6 | { 7 | class BGSActorCellEvent : 8 | public BGSActorEvent 9 | { 10 | public: 11 | enum class CellFlag 12 | { 13 | kEnter = 0x0, 14 | kLeave = 0x1 15 | }; 16 | 17 | // members 18 | std::uint32_t cellID; // 04 19 | REX::EnumSet flags; // 08 20 | }; 21 | static_assert(sizeof(BGSActorCellEvent) == 0xC); 22 | } 23 | -------------------------------------------------------------------------------- /include/RE/B/BGSActorDeathEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSActorEvent.h" 4 | 5 | namespace RE 6 | { 7 | class BGSActorDeathEvent : 8 | public BGSActorEvent 9 | { 10 | public: 11 | // members 12 | ActorHandle attacker; // 04 13 | float damage; // 08 14 | }; 15 | static_assert(sizeof(BGSActorDeathEvent) == 0xC); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BGSActorEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerHandle.h" 4 | 5 | namespace RE 6 | { 7 | class BGSActorEvent 8 | { 9 | public: 10 | // member 11 | ActorHandle actor; // 00 12 | }; 13 | static_assert(sizeof(BGSActorEvent) == 0x4); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BGSBehaviorGraphModel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESModel.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSBehaviorGraphModel : 8 | public TESModel // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSBehaviorGraphModel }; 12 | static constexpr auto VTABLE{ VTABLE::BGSBehaviorGraphModel }; 13 | }; 14 | static_assert(sizeof(BGSBehaviorGraphModel) == 0x30); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BGSBehaviorRootData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | #include "RE/S/SubgraphIdentifier.h" 5 | 6 | namespace RE 7 | { 8 | class BGSBehaviorRootData 9 | { 10 | public: 11 | // members 12 | BSFixedString idleManagerRootToUse; // 00 13 | BSFixedString behaviorRootFilename; // 08 14 | SubgraphIdentifier identifier; // 10 15 | bool firstPerson; // 18 16 | }; 17 | static_assert(sizeof(BGSBehaviorRootData) == 0x20); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSCraftingUseSound.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSCraftingUseSound : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSCraftingUseSound }; 12 | static constexpr auto VTABLE{ VTABLE::BGSCraftingUseSound }; 13 | 14 | // members 15 | BGSSoundDescriptorForm* craftingUseSound; // 08 16 | }; 17 | static_assert(sizeof(BGSCraftingUseSound) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSDirectionalAmbientLightingColors.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BGSDirectionalAmbientLightingColors 6 | { 7 | public: 8 | // members 9 | std::uint32_t colorValues[7]; // 00 10 | float fresnelPower; // 1C 11 | }; 12 | static_assert(sizeof(BGSDirectionalAmbientLightingColors) == 0x20); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/BGSDualCastDataDEF.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BGSDualCastDataDEF 6 | { 7 | public: 8 | // members 9 | BGSProjectile* projectile; // 00 10 | BGSExplosion* explosion; // 08 11 | TESEffectShader* effectShader; // 10 12 | BGSArtObject* hitEffectArt; // 18 13 | BGSImpactDataSet* impactDataSet; // 20 14 | std::uint32_t flags; // 28 15 | }; 16 | static_assert(sizeof(BGSDualCastDataDEF) == 0x30); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BGSEquipIndex.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BGSEquipIndex 6 | { 7 | public: 8 | ~BGSEquipIndex() noexcept {} // NOLINT(modernize-use-equals-default) 9 | 10 | // members 11 | std::uint32_t index; // 0 12 | }; 13 | static_assert(sizeof(BGSEquipIndex) == 0x4); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BGSFeaturedItemMessage.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSFeaturedItemMessage : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSFeaturedItemMessage }; 12 | static constexpr auto VTABLE{ VTABLE::BGSFeaturedItemMessage }; 13 | 14 | // members 15 | BGSMessage* featuredItemMessage; // 08 16 | }; 17 | static_assert(sizeof(BGSFeaturedItemMessage) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSForcedLocRefType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSForcedLocRefType : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSForcedLocRefType }; 12 | static constexpr auto VTABLE{ VTABLE::BGSForcedLocRefType }; 13 | 14 | // members 15 | BGSLocationRefType* forcedType; // 08 16 | }; 17 | static_assert(sizeof(BGSForcedLocRefType) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSInstancedQuestObjective.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class QUEST_OBJECTIVE_STATE; 6 | class BGSQuestObjective; 7 | 8 | class BGSInstancedQuestObjective 9 | { 10 | public: 11 | // members 12 | BGSQuestObjective* objective; // 00 13 | std::uint32_t instanceID; // 08 14 | REX::EnumSet enstanceState; // 0C 15 | }; 16 | static_assert(sizeof(BGSInstancedQuestObjective) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BGSInventoryItemEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerHandle.h" 4 | 5 | namespace RE 6 | { 7 | namespace InventoryInterface 8 | { 9 | class Handle; 10 | } 11 | 12 | namespace BGSInventoryItemEvent 13 | { 14 | class Event 15 | { 16 | public: 17 | ObjectRefHandle owner; // 00 18 | InventoryInterface::Handle* item; // 04 19 | }; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/B/BGSLensFlare.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSLensFlareRenderData.h" 4 | #include "RE/T/TESForm.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) BGSLensFlare : 9 | public TESForm, // 00 10 | public BSLensFlareRenderData // 20 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::BGSLensFlare }; 14 | static constexpr auto VTABLE{ VTABLE::BGSLensFlare }; 15 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kLENS }; 16 | }; 17 | static_assert(sizeof(BGSLensFlare) == 0x50); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSLocationRefType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSKeyword.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSLocationRefType : 8 | public BGSKeyword // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSLocationRefType }; 12 | static constexpr auto VTABLE{ VTABLE::BGSLocationRefType }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kLCRT }; 14 | }; 15 | static_assert(sizeof(BGSLocationRefType) == 0x28); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BGSMenuDisplayObject.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSMenuDisplayObject : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSMenuDisplayObject }; 12 | static constexpr auto VTABLE{ VTABLE::BGSMenuDisplayObject }; 13 | 14 | // members 15 | TESBoundObject* menuDispObject; // 08 16 | }; 17 | static_assert(sizeof(BGSMenuDisplayObject) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSMenuIcon.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESForm.h" 4 | #include "RE/T/TESIcon.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) BGSMenuIcon : 9 | public TESForm, // 00 10 | public TESIcon // 20 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::BGSMenuIcon }; 14 | static constexpr auto VTABLE{ VTABLE::BGSMenuIcon }; 15 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kMICN }; 16 | }; 17 | static_assert(sizeof(BGSMenuIcon) == 0x30); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSNativeTerminalForm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSNativeTerminalForm : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSNativeTerminalForm }; 12 | static constexpr auto VTABLE{ VTABLE::BGSNativeTerminalForm }; 13 | 14 | // members 15 | BGSTerminal* terminal; // 08 16 | }; 17 | static_assert(sizeof(BGSNativeTerminalForm) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSNavmeshableObject.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTSmartPointer.h" 4 | 5 | namespace RE 6 | { 7 | class NavMesh; 8 | 9 | class BGSNavmeshableObject 10 | { 11 | public: 12 | static constexpr auto RTTI{ RTTI::BGSNavmeshableObject }; 13 | 14 | // members 15 | BSTSmartPointer embeddedNavmesh; // 0 16 | }; 17 | static_assert(sizeof(BGSNavmeshableObject) == 0x8); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSOutfit.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | #include "RE/T/TESForm.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) BGSOutfit : 9 | public TESForm // 00 10 | { 11 | public: 12 | static constexpr auto RTTI{ RTTI::BGSOutfit }; 13 | static constexpr auto VTABLE{ VTABLE::BGSOutfit }; 14 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kOTFT }; 15 | 16 | // members 17 | BSTArray outfitItems; // 20 18 | }; 19 | static_assert(sizeof(BGSOutfit) == 0x38); 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/B/BGSPackIn.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESForm.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSPackIn : 8 | public TESForm // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSPackIn }; 12 | static constexpr auto VTABLE{ VTABLE::BGSPackIn }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kPKIN }; 14 | }; 15 | static_assert(sizeof(BGSPackIn) == 0x20); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BGSRefAliasInstanceData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | 5 | namespace RE 6 | { 7 | class BGSRefAlias; 8 | 9 | class BGSRefAliasInstanceData 10 | { 11 | public: 12 | // members 13 | TESQuest* quest; // 00 14 | BGSRefAlias* alias; // 08 15 | BSTArray* instancedPackages; // 10 16 | }; 17 | static_assert(sizeof(BGSRefAliasInstanceData) == 0x18); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSScenePhase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESCondition.h" 4 | 5 | namespace RE 6 | { 7 | class BGSScenePhase 8 | { 9 | public: 10 | // members 11 | TESCondition startConditions; // 00 12 | TESCondition completionConditions; // 08 13 | std::uint16_t phaseFlags; // 10 14 | bool active; // 12 15 | bool scriptEndRun; // 13 16 | bool runEnd; // 14 17 | }; 18 | static_assert(sizeof(BGSScenePhase) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BGSSkinForm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseFormComponent.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSSkinForm : 8 | public BaseFormComponent // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSSkinForm }; 12 | static constexpr auto VTABLE{ VTABLE::BGSSkinForm }; 13 | 14 | // members 15 | TESObjectARMO* formSkin; // 08 16 | }; 17 | static_assert(sizeof(BGSSkinForm) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BGSTextureModel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESModel.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BGSTextureModel : 8 | public TESModel // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BGSTextureModel }; 12 | static constexpr auto VTABLE{ VTABLE::BGSTextureModel }; 13 | }; 14 | static_assert(sizeof(BGSTextureModel) == 0x30); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BGSTopicSubtypeUnion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class DIALOGUE_SUBTYPE; 6 | 7 | class BGSTopicSubtypeUnion 8 | { 9 | public: 10 | enum class TOPIC_MODE; 11 | 12 | // members 13 | REX::EnumSet mode; // 0 14 | union 15 | { 16 | DIALOGUE_SUBTYPE generalTopicSubtype; 17 | std::uint32_t specificTopicID; 18 | }; // 4 19 | }; 20 | static_assert(sizeof(BGSTopicSubtypeUnion) == 0x8); 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/B/BGSTypedFormValuePair.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BGSTypedFormValuePair 6 | { 7 | union SharedVal 8 | { 9 | std::uint32_t i; 10 | float f; 11 | }; 12 | static_assert(sizeof(SharedVal) == 0x4); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BIPED_MODEL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class __declspec(novtable) BIPED_MODEL 6 | { 7 | public: 8 | // members 9 | std::uint32_t bipedObjectSlots; // 0 10 | }; 11 | static_assert(sizeof(BIPED_MODEL) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/B/BSAnimationGraphEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class BSAnimationGraphEvent 8 | { 9 | public: 10 | // members 11 | const std::uint64_t holderID; // 00 12 | const BSFixedString tag; // 08 13 | const BSFixedString payload; // 10 14 | }; 15 | static_assert(sizeof(BSAnimationGraphEvent) == 0x18); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSAudioUtil.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BSAudioUtil 6 | { 7 | inline std::uint16_t ClampFadeTimeSeconds(float a_seconds) 8 | { 9 | auto result = a_seconds * 1000; 10 | return (result > 0xFFFF) ? 0xFFFF : static_cast(a_seconds); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/BSBound.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiExtraData.h" 4 | #include "RE/N/NiPoint.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) BSBound : 9 | public NiExtraData // 00 10 | { 11 | public: 12 | static constexpr auto RTTI{ RTTI::BSBound }; 13 | static constexpr auto VTABLE{ VTABLE::BSBound }; 14 | static constexpr auto Ni_RTTI{ Ni_RTTI::BSBound }; 15 | 16 | // members 17 | NiPoint3 center; // 18 18 | NiPoint3 extents; // 24 19 | }; 20 | static_assert(sizeof(BSBound) == 0x30); 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/B/BSContainer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BSContainer 6 | { 7 | enum class ForEachResult 8 | { 9 | kContinue = 0x0, 10 | kStop = 0x1 11 | }; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/BSCriticalSection.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSCriticalSection 6 | { 7 | public: 8 | // members 9 | REX::W32::CRITICAL_SECTION criticalSection; // 00 10 | }; 11 | static_assert(sizeof(BSCriticalSection) == 0x28); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/B/BSEventFlag.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSEventFlag 6 | { 7 | public: 8 | // members 9 | void* event{ nullptr }; // 0 10 | }; 11 | static_assert(sizeof(BSEventFlag) == 0x8); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/B/BSFurnitureMarker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class BSFurnitureMarker 8 | { 9 | public: 10 | // members 11 | NiPoint3 position; // 00 12 | BGSKeyword* actorMustHaveKeyword; // 10 13 | float heading; // 18 14 | std::uint32_t allowedAnimations; // 1C 15 | }; 16 | static_assert(sizeof(BSFurnitureMarker) == 0x20); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSInputEventSingleUser.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSInputEventReceiver.h" 4 | #include "RE/B/BSInputEventUser.h" 5 | 6 | namespace RE 7 | { 8 | class BSInputEventSingleUser : 9 | public BSInputEventReceiver, // 00 10 | public BSInputEventUser // 10 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::BSInputEventSingleUser }; 14 | static constexpr auto VTABLE{ VTABLE::BSInputEventSingleUser }; 15 | }; 16 | static_assert(sizeof(BSInputEventSingleUser) == 0x20); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSLightingShaderMaterial.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSLightingShaderMaterialBase.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BSLightingShaderMaterial : 8 | public BSLightingShaderMaterialBase // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BSLightingShaderMaterial }; 12 | static constexpr auto VTABLE{ VTABLE::BSLightingShaderMaterial }; 13 | }; 14 | static_assert(sizeof(BSLightingShaderMaterial) == 0xC0); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshClosedDoorInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTSmartPointer.h" 4 | 5 | namespace RE 6 | { 7 | class BSPathingDoor; 8 | 9 | class BSNavmeshClosedDoorInfo 10 | { 11 | public: 12 | // members 13 | BSTSmartPointer door; // 00 14 | std::uint16_t iriangleIndex; // 08 15 | }; 16 | static_assert(sizeof(BSNavmeshClosedDoorInfo) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshCoverEdge.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSNavmeshCoverEdgeBase.h" 4 | 5 | namespace RE 6 | { 7 | class BSNavmeshCoverEdge : 8 | public BSNavmeshCoverEdgeBase // 0 9 | { 10 | public: 11 | // members 12 | std::uint16_t vertexArray[2]; // 0 13 | std::uint32_t data; // 4 14 | }; 15 | static_assert(sizeof(BSNavmeshCoverEdge) == 0x8); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshCoverEdgeBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSNavmeshCoverEdgeBase 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshEdgeExtraInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSNavmeshTriangleEdgePortal.h" 4 | 5 | namespace RE 6 | { 7 | enum class EDGE_EXTRA_INFO_TYPE; 8 | 9 | class BSNavmeshEdgeExtraInfo 10 | { 11 | public: 12 | // members 13 | REX::EnumSet type; // 0 14 | BSNavmeshTriangleEdgePortal portal; // 4 15 | }; 16 | static_assert(sizeof(BSNavmeshEdgeExtraInfo) == 0xC); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshTriangle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSNavmeshTriangle 6 | { 7 | public: 8 | // members 9 | std::uint16_t vertices[3]; // 00 10 | std::uint16_t triangles[3]; // 06 11 | float height; // 0C 12 | std::uint32_t triangleFlags; // 10 13 | std::int8_t traversalFlags; // 14 14 | }; 15 | static_assert(sizeof(BSNavmeshTriangle) == 0x18); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshTriangleDoorPortal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTSmartPointer.h" 4 | 5 | namespace RE 6 | { 7 | class BSPathingDoor; 8 | 9 | class BSNavmeshTriangleDoorPortal 10 | { 11 | public: 12 | // members 13 | BSTSmartPointer door; // 00 14 | std::uint16_t owningTriangleIndex; // 08 15 | }; 16 | static_assert(sizeof(BSNavmeshTriangleDoorPortal) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshTriangleEdgePortal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSNavmeshTriangleEdgePortal 6 | { 7 | public: 8 | // members 9 | std::uint32_t otherMeshID; // 0 10 | std::uint16_t triangle; // 4 11 | std::int8_t edgeIndex; // 6 12 | }; 13 | static_assert(sizeof(BSNavmeshTriangleEdgePortal) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshVertex.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class BSNavmeshVertex 8 | { 9 | public: 10 | // members 11 | NiPoint3 location; // 0 12 | }; 13 | static_assert(sizeof(BSNavmeshVertex) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BSNavmeshWaypoint.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class BSNavmeshWaypoint 8 | { 9 | public: 10 | // members 11 | NiPoint3 position; // 00 12 | std::uint16_t triangleIndex; // 0C 13 | std::uint32_t flags; // 10 14 | }; 15 | static_assert(sizeof(BSNavmeshWaypoint) == 0x14); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSPackedTaskQueue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTMessageQueue.h" 4 | 5 | namespace RE 6 | { 7 | class BSPackedTask; 8 | 9 | class BSPackedTaskQueue 10 | { 11 | public: 12 | using UnpackFunc_t = void (*)(const BSPackedTask&); 13 | 14 | // members 15 | BSTCommonScrapHeapMessageQueue queue; // 00 16 | UnpackFunc_t* unpackFunc; // 28 17 | }; 18 | static_assert(sizeof(BSPackedTaskQueue) == 0x30); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSPointerAllocator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSPointerAllocator 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/B/BSPreCulledObjects.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiAVObject; 6 | 7 | class BSPreCulledObjects 8 | { 9 | public: 10 | class ObjectRecord 11 | { 12 | public: 13 | // members 14 | NiAVObject* obj{ nullptr }; // 00 15 | std::uint32_t flags{ 0 }; // 08 16 | }; 17 | static_assert(sizeof(ObjectRecord) == 0x10); 18 | }; 19 | static_assert(std::is_empty_v); 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/B/BSReloadShaderI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSIStream; 6 | 7 | class __declspec(novtable) BSReloadShaderI 8 | { 9 | public: 10 | static constexpr auto RTTI{ RTTI::BSReloadShaderI }; 11 | static constexpr auto VTABLE{ VTABLE::BSReloadShaderI }; 12 | 13 | // add 14 | virtual void ReloadShaders(BSIStream* a_stream) = 0; // 00 15 | }; 16 | static_assert(sizeof(BSReloadShaderI) == 0x8); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_Archive2_ClearRegistryEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE::BSResource 4 | { 5 | namespace Archive2 6 | { 7 | class ClearRegistryEvent 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_Archive2_StreamOpenedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE::BSResource 6 | { 7 | namespace Archive2 8 | { 9 | class StreamOpenedEvent 10 | { 11 | public: 12 | // members 13 | BSFixedString streamName; // 00 14 | BSFixedString sourceName; // 08 15 | std::uint64_t startOffset; // 10 16 | std::uint32_t sizeInArchive; // 18 17 | }; 18 | static_assert(sizeof(StreamOpenedEvent) == 0x20); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_EntryBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSResource_ID.h" 4 | #include "RE/B/BSResource_Stream.h" 5 | #include "RE/B/BSTAtomicValue.h" 6 | #include "RE/B/BSTSmartPointer.h" 7 | 8 | namespace RE::BSResource 9 | { 10 | class EntryBase 11 | { 12 | public: 13 | // members 14 | ID name; // 00 15 | BSTAtomicValue ctrl; // 0C 16 | BSTSmartPointer stream; // 10 17 | }; 18 | static_assert(sizeof(EntryBase) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_EntryBucketQueue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSResource_EntryQueue.h" 4 | 5 | namespace RE::BSResource 6 | { 7 | template 8 | class EntryBucketQueue 9 | { 10 | public: 11 | // members 12 | EntryQueue buckets[N]; // 00 13 | volatile std::uint32_t step; // ?? 14 | }; 15 | static_assert(sizeof(EntryBucketQueue) == 0xC8); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_EntryQueue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSSpinLock.h" 4 | 5 | namespace RE::BSResource 6 | { 7 | template 8 | class EntryQueue 9 | { 10 | public: 11 | // members 12 | BSNonReentrantSpinLock lock; // 00 13 | T* head; // 08 14 | T** tail; // 10 15 | }; 16 | static_assert(sizeof(EntryQueue) == 0x18); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_ErrorCode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE::BSResource 4 | { 5 | enum class ErrorCode : std::uint32_t 6 | { 7 | kNone = 0x0, 8 | kNotExist = 0x1, 9 | kInvalidPath = 0x2, 10 | kFileError = 0x3, 11 | kInvalidType = 0x4, 12 | kMemoryError = 0x5, 13 | kBusy = 0x6, 14 | kInvalidParam = 0x7, 15 | kUnsupported = 0x8 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_FileID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE::BSResource 4 | { 5 | class FileID 6 | { 7 | public: 8 | [[nodiscard]] bool operator==(const FileID&) const noexcept = default; 9 | 10 | // members 11 | std::uint32_t file = 0; // 0 12 | std::uint32_t ext = 0; // 4 13 | }; 14 | static_assert(sizeof(FileID) == 0x8); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_ID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSResource_FileID.h" 4 | 5 | namespace RE::BSResource 6 | { 7 | class ID : 8 | public FileID // 0 9 | { 10 | public: 11 | [[nodiscard]] bool operator==(const ID&) const noexcept = default; 12 | 13 | // members 14 | std::uint32_t dir = 0; // 8 15 | }; 16 | static_assert(sizeof(ID) == 0xC); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_Info.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE::BSResource 4 | { 5 | class Info 6 | { 7 | public: 8 | // members 9 | REX::W32::FILETIME modifyTime; // 00 10 | REX::W32::FILETIME createTime; // 08 11 | std::uint64_t fileSize; // 10 12 | }; 13 | static_assert(sizeof(Info) == 0x18); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_SDirectory2.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSResource_Archive2_Index.h" 4 | 5 | namespace RE::BSResource::SDirectory2 6 | { 7 | class Cursor : 8 | public Archive2::Index::CursorWithEntry // 000 9 | { 10 | public: 11 | // members 12 | Archive2::Index* index; // 170 13 | }; 14 | static_assert(sizeof(Cursor) == 0x178); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSResource_SeekMode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE::BSResource 4 | { 5 | enum class SeekMode 6 | { 7 | kSet = 0x0, 8 | kCurrent = 0x1, 9 | kEnd = 0x2 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/B/BSSaveDataSystemUtility.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSSaveDataSystemUtility 6 | { 7 | public: 8 | enum class RESULT 9 | { 10 | kSuccess = 0x0, 11 | kCancel = 0x1, 12 | kFailed = 0x2, 13 | }; 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSSaveDataSystemUtilityImage.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSSaveDataSystemUtilityImage 6 | { 7 | public: 8 | // members 9 | std::uint32_t size; // 00 10 | std::uint32_t width; // 04 11 | std::uint32_t height; // 08 12 | char* buffer; // 10 13 | }; 14 | static_assert(sizeof(BSSaveDataSystemUtilityImage) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSScaleformExternalTexture.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | #include "RE/N/NiPointer.h" 5 | 6 | namespace RE 7 | { 8 | class NiTexture; 9 | 10 | class BSScaleformExternalTexture 11 | { 12 | public: 13 | // members 14 | NiPointer gamebryoTexture; // 00 15 | std::uint32_t renderTarget; // 08 16 | BSFixedString texturePath; // 10 17 | }; 18 | static_assert(sizeof(BSScaleformExternalTexture) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSScaleformTranslator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTranslator.h" 4 | #include "Scaleform/G/GFX_Translator.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) BSScaleformTranslator : 9 | public Scaleform::GFx::Translator 10 | { 11 | public: 12 | // members 13 | BSTranslator translator; //20 14 | }; 15 | static_assert(sizeof(BSScaleformTranslator) == 0x50); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSScript_IClientVM.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BSScript 6 | { 7 | class __declspec(novtable) IClientVM 8 | { 9 | public: 10 | static constexpr auto RTTI{ RTTI::BSScript__IClientVM }; 11 | static constexpr auto VTABLE{ VTABLE::BSScript__IClientVM }; 12 | 13 | virtual ~IClientVM(); // 00 14 | 15 | // add 16 | virtual bool IsVMFrozen() const; // 01 17 | virtual void PreSave(); // 02 18 | }; 19 | static_assert(sizeof(IClientVM) == 0x8); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/B/BSScript_Internal_AttachedScript.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSScript_Object.h" 4 | #include "RE/B/BSTPointerAndFlags.h" 5 | #include "RE/B/BSTSmartPointer.h" 6 | 7 | namespace RE 8 | { 9 | namespace BSScript 10 | { 11 | namespace Internal 12 | { 13 | class AttachedScript : 14 | public BSTPointerAndFlags, 1> // 00 15 | {}; 16 | static_assert(sizeof(AttachedScript) == 0x8); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSScript_Internal_SuspendedStack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTSmartPointer.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSScript 8 | { 9 | class Stack; 10 | 11 | namespace Internal 12 | { 13 | class IFuncCallQuery; 14 | 15 | class SuspendedStack 16 | { 17 | public: 18 | // members 19 | BSTSmartPointer stack; // 00 20 | BSTSmartPointer funcCallQuery; // 08 21 | }; 22 | static_assert(sizeof(SuspendedStack) == 0x10); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /include/RE/B/BSScript_MergedBoundScript.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTSmartPointer.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSScript 8 | { 9 | class BoundScript; 10 | 11 | class MergedBoundScript 12 | { 13 | public: 14 | // members 15 | BSTSmartPointer childScript; // 00 16 | BSTSmartPointer parentScript; // 08 17 | }; 18 | static_assert(sizeof(MergedBoundScript) == 0x10); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/B/BSScript_StatsEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BSScript 6 | { 7 | class StatsEvent 8 | { 9 | public: 10 | // members 11 | std::uint32_t runningStacksCount; // 00 12 | std::uint32_t suspendedStacksCount; // 04 13 | std::uint32_t functionMsgCount; // 08 14 | std::uint32_t detachedObjectCount; // 0C 15 | }; 16 | static_assert(sizeof(StatsEvent) == 0x10); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/B/BSSemaphore.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSSemaphoreBase 6 | { 7 | public: 8 | // members 9 | void* semaphore; // 00 10 | }; 11 | static_assert(sizeof(BSSemaphoreBase) == 0x08); 12 | 13 | class BSSemaphore : 14 | public BSSemaphoreBase 15 | { 16 | public: 17 | }; 18 | static_assert(sizeof(BSSemaphore) == 0x08); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSShaderPropertyLightData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | 5 | namespace RE 6 | { 7 | class BSLight; 8 | 9 | class BSShaderPropertyLightData 10 | { 11 | public: 12 | // members 13 | std::uint32_t lightListFence; // 00 14 | std::uint32_t shadowAccumFlags; // 04 15 | std::uint32_t lightListChanged; // 08 16 | BSTArray lightList; // 10 17 | }; 18 | static_assert(sizeof(BSShaderPropertyLightData) == 0x28); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSSpring_SpringState.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSSpring 8 | { 9 | template 10 | class SpringState 11 | { 12 | public: 13 | // members 14 | T position; // 00 15 | T velocity; // ?? 16 | float springConstant; // ?? 17 | }; 18 | 19 | extern template class SpringState; 20 | extern template class SpringState; 21 | extern template class SpringState; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /include/RE/B/BSSteamAwardsSystemUtility.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSAwardsSystemUtility.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BSSteamAwardsSystemUtility : 8 | public BSAwardsSystemUtility // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BSSteamAwardsSystemUtility }; 12 | static constexpr auto VTABLE{ VTABLE::BSSteamAwardsSystemUtility }; 13 | 14 | virtual ~BSSteamAwardsSystemUtility() {} // 00 15 | }; 16 | static_assert(sizeof(BSSteamAwardsSystemUtility) == 0x8); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/BSStorageDefs.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/M/MemoryManager.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSStorageDefs 8 | { 9 | enum class ErrorCode; 10 | enum class SeekMode; 11 | 12 | class StreamBuffer 13 | { 14 | public: 15 | // members 16 | std::size_t size; // 00 17 | MemoryManager::AutoScrapBuffer buffer; // 08 18 | void* ptrCur; // 10 19 | }; 20 | static_assert(sizeof(StreamBuffer) == 0x18); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /include/RE/B/BSStreamHeader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSStreamHeader 6 | { 7 | public: 8 | // members 9 | std::uint32_t version; // 000 10 | char author[64]; // 004 11 | char processScript[64]; // 044 12 | char exportScript[64]; // 084 13 | char maxFilePath[260]; // 0C4 14 | }; 15 | static_assert(sizeof(BSStreamHeader) == 0x1C8); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/B/BSSystemFileStreamer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BSSystemFileStreamer 6 | { 7 | class ID 8 | { 9 | public: 10 | // members 11 | std::uint32_t id; // 0 12 | }; 13 | static_assert(sizeof(ID) == 0x4); 14 | 15 | inline void UncacheAll(bool a_block) 16 | { 17 | using func_t = decltype(&UncacheAll); 18 | static REL::Relocation func{ RE::ID::BSSystemFileStreamer::UncacheAll }; 19 | return func(a_block); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /include/RE/B/BSThreadEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSThreadEvent 6 | { 7 | public: 8 | enum class Event 9 | { 10 | kOnStartup = 0x0, 11 | kOnShutdown = 0x1 12 | }; 13 | 14 | static void InitSDM() 15 | { 16 | using func_t = decltype(&BSThreadEvent::InitSDM); 17 | static REL::Relocation func{ ID::BSThreadEvent::InitSDM }; 18 | return func(); 19 | } 20 | }; 21 | static_assert(std::is_empty_v); 22 | } 23 | -------------------------------------------------------------------------------- /include/RE/B/BSTranslator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | #include "RE/B/BSTHashMap.h" 5 | 6 | namespace RE 7 | { 8 | class BSTranslator 9 | { 10 | public: 11 | // members 12 | BSTHashMap translationMap; //00 13 | }; 14 | static_assert(sizeof(BSTranslator) == 0x30); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BSUtilityShader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSShader.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BSUtilityShader : 8 | public BSShader // 000 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::BSUtilityShader }; 12 | static constexpr auto VTABLE{ VTABLE::BSUtilityShader }; 13 | 14 | // members 15 | std::uint32_t currentTechniqueID; // 118 16 | std::uint32_t currentDecl; // 11C 17 | }; 18 | static_assert(sizeof(BSUtilityShader) == 0x120); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/B/BSVisit.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class bhkNiCollisionObject; 6 | class BSGeometry; 7 | class NiAVObject; 8 | 9 | namespace BSVisit 10 | { 11 | enum class BSVisitControl 12 | { 13 | kContinue = 0x0, 14 | kStop = 0x1 15 | }; 16 | 17 | BSVisitControl TraverseScenegraphGeometries(NiAVObject* a_object, std::function a_func); 18 | BSVisitControl TraverseScenegraphObjects(NiAVObject* a_object, std::function a_func); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/B/BarterMenuTentativeInventoryUIInterface.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/I/InventoryUserUIInterface.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) BarterMenuTentativeInventoryUIInterface : 8 | public InventoryUserUIInterface // 00 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(BarterMenuTentativeInventoryUIInterface) == 0x80); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/Bleedout.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace Bleedout 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | Actor* actorBleedingOut; // 00 12 | }; 13 | static_assert(sizeof(Event) == 0x8); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/B/BobbleheadCollected.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BobbleheadCollected 6 | { 7 | class Event 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/B/BooksRead.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace BooksRead 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | const TESObjectBOOK* book; 12 | bool advancedActorValue; 13 | bool addedPerk; 14 | }; 15 | static_assert(sizeof(Event) == 0x10); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/B/bhkCollisionQueryResultHandle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class bhkCollisionQueryResultHandle 6 | { 7 | public: 8 | // members 9 | std::uint64_t data; // 00 10 | }; 11 | static_assert(sizeof(bhkCollisionQueryResultHandle) == 0x08); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/B/bhkUtilFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class bhkNPCollisionObject; 6 | class NiAVObject; 7 | 8 | namespace bhkUtilFunctions 9 | { 10 | inline bhkNPCollisionObject* FindFirstCollisionObject(NiAVObject* a_object) 11 | { 12 | using func_t = decltype(&bhkUtilFunctions::FindFirstCollisionObject); 13 | static REL::Relocation func{ ID::bhkUtilFunctions::FindFirstCollisionObject }; 14 | return func(a_object); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/C/CALCED_OBJECT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/C/ContainerItemExtra.h" 4 | #include "RE/I/INSTANCE_FILTER.h" 5 | 6 | namespace RE 7 | { 8 | class CALCED_OBJECT 9 | { 10 | public: 11 | // members 12 | TESBoundObject* object; // 00 13 | const char* overrideName; // 08 14 | std::int32_t count; // 10 15 | ContainerItemExtra itemExtra; // 18 16 | INSTANCE_FILTER instanceFilter; // 30 17 | }; 18 | static_assert(sizeof(CALCED_OBJECT) == 0x58); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/C/CFilter.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CFilter 6 | { 7 | public: 8 | ~CFilter() noexcept {} // intentional 9 | 10 | // members 11 | std::uint32_t filter; // 0 12 | }; 13 | static_assert(sizeof(CFilter) == 0x4); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/C/CLASS_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CLASS_DATA 6 | { 7 | public: 8 | // members 9 | std::int32_t serviceFlags; // 0 10 | float bleedoutDefault; // 4 11 | }; 12 | static_assert(sizeof(CLASS_DATA) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/C/COMMAND_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class COMMAND_TYPE : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kCall = 0x1, 9 | kFollow = 0x2, 10 | kMove = 0x3, 11 | kAttack = 0x4, 12 | kInspect = 0x5, 13 | kRetrieve = 0x6, 14 | kStay = 0x7, 15 | kRelease = 0x8, 16 | kHeal = 0x9, 17 | kAssign = 0xA, 18 | kRide = 0xB, 19 | kEnter = 0xC, 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/C/COMPILER_NAME.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class COMPILER_NAME : std::int32_t 6 | { 7 | kDefault = 0x0, 8 | kSystemWindow = 0x1, 9 | kDialogue = 0x2 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/C/CONDITIONITEMOBJECT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class CONDITIONITEMOBJECT : std::int32_t 6 | { 7 | kSelf = 0x0, 8 | kTarget = 0x1, 9 | kRef = 0x2, 10 | kCombatTarget = 0x3, 11 | kLinkedRef = 0x4, 12 | kQuestAlias = 0x5, 13 | kPackData = 0x6, 14 | kEventData = 0x7, 15 | kCommandTarget = 0x8, 16 | kEventCameraRef = 0x9, 17 | kMyKiller = 0xA 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/C/CONT_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CONT_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t contFlags; // 00 10 | }; 11 | static_assert(sizeof(CONT_DATA) == 0x1); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/C/CachedValueData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CachedValueData 6 | { 7 | public: 8 | // members 9 | float value; // 0 10 | bool dirty; // 4 11 | }; 12 | static_assert(sizeof(CachedValueData) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/C/CellAttachDetachEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CellAttachDetachEvent 6 | { 7 | public: 8 | enum class EVENT_TYPE : std::int32_t 9 | { 10 | kPreAttach = 0x0, 11 | kPostAttach = 0x1, 12 | kPreDetach = 0x2, 13 | kPostDetach = 0x3 14 | }; 15 | 16 | // members 17 | TESObjectCELL* cell; // 00 18 | REX::EnumSet type; // 08 19 | }; 20 | static_assert(sizeof(CellAttachDetachEvent) == 0x10); 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/C/CombatStyleCoverData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CombatStyleCoverData 6 | { 7 | public: 8 | // members 9 | float coverSearchDistanceMult; // 0 10 | }; 11 | static_assert(sizeof(CombatStyleCoverData) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/C/CombatStyleLongRangeData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CombatStyleLongRangeData 6 | { 7 | public: 8 | // members 9 | float strafeMult; // 00 10 | float adjustRangeMult; // 04 11 | float crouchMult; // 08 12 | float waitMult; // 0C 13 | float rangeMult; // 10 14 | }; 15 | static_assert(sizeof(CombatStyleLongRangeData) == 0x14); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/C/CombatStyleRangedData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CombatStyleRangedData 6 | { 7 | public: 8 | // members 9 | float accuracyMult; // 0 10 | }; 11 | static_assert(sizeof(CombatStyleRangedData) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/C/CommandedActorData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerHandle.h" 4 | 5 | namespace RE 6 | { 7 | class CommandedActorData 8 | { 9 | public: 10 | // members 11 | ActorHandle commandedActor; // 00 12 | ActiveEffect* activeEffect; // 08 13 | }; 14 | static_assert(sizeof(CommandedActorData) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/C/ConcreteObjectFormFactory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/C/ConcreteFormFactory.h" 4 | 5 | namespace RE 6 | { 7 | template 8 | class __declspec(novtable) ConcreteObjectFormFactory : 9 | public ConcreteFormFactory // 00 10 | { 11 | public: 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/C/CreatureSounds.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | 5 | namespace RE 6 | { 7 | class CREATURE_SOUND; 8 | 9 | class CreatureSounds 10 | { 11 | public: 12 | // members 13 | BSTArray consciousLoops; // 00 14 | bool stopLoopWhenUnconscious; // 18 15 | }; 16 | static_assert(sizeof(CreatureSounds) == 0x20); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/C/CrimeGoldStruct.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class CrimeGoldStruct 6 | { 7 | public: 8 | // members 9 | std::uint32_t violent; // 00 10 | std::uint32_t nonViolent; // 04 11 | std::uint32_t totalNonViolentAccumulated; // 08 12 | std::uint32_t totalViolentAccumulated; // 0C 13 | }; 14 | static_assert(sizeof(CrimeGoldStruct) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/C/CurrentRadsDisplayMagnitude.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class CurrentRadsDisplayMagnitude : 8 | public BSTValueEvent 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(CurrentRadsDisplayMagnitude) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/C/CurrentRadsPercentOfLethal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class CurrentRadsPercentOfLethal : 8 | public BSTValueEvent 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(CurrentRadsPercentOfLethal) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/C/CursorMenu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/G/GameMenuBase.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) CursorMenu : 8 | public GameMenuBase // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::CursorMenu }; 12 | static constexpr auto VTABLE{ VTABLE::CursorMenu }; 13 | static constexpr auto MENU_NAME{ "CursorMenu"sv }; 14 | 15 | // members 16 | std::unique_ptr cursor; // E0 17 | }; 18 | static_assert(sizeof(CursorMenu) == 0xE8); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/C/CustomMarkerUpdate.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace CustomMarkerUpdate 6 | { 7 | class Event 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/D/DEFAULT_OBJECT_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class DEFAULT_OBJECT_TYPE : std::int32_t 6 | { 7 | kMisc = 0x0, 8 | kFacegen = 0x1, 9 | kMovement = 0x2, 10 | kActions = 0x3, 11 | kItems = 0x4, 12 | kSounds = 0x5, 13 | kKeywords = 0x6 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/D/DIALOGUE_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class DIALOGUE_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t flags; // 0 10 | std::int8_t type; // 1 11 | std::uint16_t subtype; // 2 12 | }; 13 | static_assert(sizeof(DIALOGUE_DATA) == 0x4); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/D/DIALOGUE_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class DIALOGUE_TYPE : std::int32_t 6 | { 7 | kPlayerDialogue = 0x0, 8 | kCommandDialogue = 0x1, 9 | kSceneDialogue = 0x2, 10 | kCombat = 0x3, 11 | kFavors = 0x4, 12 | kDetection = 0x5, 13 | kService = 0x6, 14 | kMiscellaneous = 0x7, 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/D/DIRECTION_VAL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class DIRECTION_VAL : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kUp = 0x1, 9 | kRight = 0x2, 10 | kDown = 0x3, 11 | kLeft = 0x4 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/D/DamageImpactData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | #include "RE/N/NiPointer.h" 5 | 6 | namespace RE 7 | { 8 | class bhkNPCollisionObject; 9 | 10 | class DamageImpactData 11 | { 12 | // members 13 | NiPoint3A location; // 00 14 | NiPoint3A normal; // 10 15 | NiPoint3A velocity; // 20 16 | NiPointer colObj; // 30 17 | }; 18 | static_assert(sizeof(DamageImpactData) == 0x40); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/D/DecalData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/D/DECAL_DATA_DATA.h" 4 | 5 | namespace RE 6 | { 7 | class DecalData 8 | { 9 | public: 10 | // members 11 | DECAL_DATA_DATA data; // 00 12 | }; 13 | static_assert(sizeof(DecalData) == 0x24); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/D/DifficultyLevel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class DifficultyLevel : std::int32_t 6 | { 7 | kVeryEasy = 0x0, 8 | kLow = 0x0, 9 | kEasy = 0x1, 10 | kNormal = 0x2, 11 | kHard = 0x3, 12 | kVeryHard = 0x4, 13 | kSurvival = 0x5, 14 | kTrueSurvival = 0x6, 15 | kHigh = 0x6, 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/D/DisableHeavyItemsFunc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class DisableHeavyItemsFunc 6 | { 7 | public: 8 | // members 9 | float playerCurrEncumbrance; // 00 10 | float playerMaxEncumbrance; // 04 11 | float containerCurrEncumbrance; // 08 12 | float containerMaxEncumbrance; // 0C 13 | }; 14 | static_assert(sizeof(DisableHeavyItemsFunc) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/D/DisconnectHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSInputEventUser.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) DisconnectHandler : 8 | public BSInputEventUser 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::DisconnectHandler }; 12 | static constexpr auto VTABLE{ VTABLE::DisconnectHandler }; 13 | }; 14 | static_assert(sizeof(DisconnectHandler) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/D/DisplayItemModel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BaseLoadedInventoryModel.h" 4 | 5 | namespace RE 6 | { 7 | class DisplayItemModel : 8 | public BaseLoadedInventoryModel // 00 9 | { 10 | public: 11 | // members 12 | float itemRotation; // 40 13 | std::uint32_t uniqueIndex; // 44 14 | std::uint16_t column; // 48 15 | std::uint16_t index; // 4A 16 | std::uint16_t row; // 4C 17 | }; 18 | static_assert(sizeof(DisplayItemModel) == 0x50); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/EDGE_EXTRA_INFO_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class EDGE_EXTRA_INFO_TYPE : std::int32_t 6 | { 7 | kInvalid = -1, 8 | kPortal = 0x0, 9 | kLedgeUp = 0x1, 10 | kLedgeDown = 0x2, 11 | kEnableDisablePortal = 0x3 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/E/ENCOUNTER_ZONE_GAME_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class ENCOUNTER_ZONE_GAME_DATA 6 | { 7 | public: 8 | // members 9 | std::uint32_t detachTime; // 00 10 | std::uint32_t attachTime; // 04 11 | std::uint32_t resetTime; // 08 12 | std::uint16_t zoneLevel; // 0C 13 | }; 14 | static_assert(sizeof(ENCOUNTER_ZONE_GAME_DATA) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/E/ENUM_COMPARISON_CONDITION.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ENUM_COMPARISON_CONDITION : std::int32_t 6 | { 7 | kEqual = 0x0, 8 | kNotEqual = 0x1, 9 | kGreaterThan = 0x2, 10 | kGreaterThanEqual = 0x3, 11 | kLessThan = 0x4, 12 | kLessThanEqual = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/E/ENUM_LOD_MULT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ENUM_LOD_MULT : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kObjects = 0x1, 9 | kItems = 0x2, 10 | kActors = 0x3, 11 | kTrees = 0x4, 12 | kLandscape = 0x5, 13 | kDistantLOD = 0x6, 14 | kActorBodyPart = 0x7, 15 | kRenderedMenu = 0x8, 16 | kInvisible = 0x9, 17 | kSkyCell = 0xA, 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/EQUIP_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class EQUIP_TYPE 6 | { 7 | kNone = 0x0, 8 | kEquipped = 0x1, 9 | kLeftHandEquip = 0x2, 10 | kRightHandEquip = 0x3, 11 | kBothHandEquip = 0x4, 12 | kWillEquipAgain = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/E/EaseOutInterpolator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class EaseOutInterpolator 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/E/EffectItemData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class EffectItemData 6 | { 7 | public: 8 | // members 9 | float magnitude; // 0 10 | std::int32_t area; // 4 11 | std::int32_t duration; // 8 12 | }; 13 | static_assert(sizeof(EffectItemData) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/E/EquipSlotData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class EquipSlotData 8 | { 9 | public: 10 | // members 11 | BGSEquipSlot* equipSlot; // 00 12 | BSFixedString equipSlotNode; // 08 13 | }; 14 | static_assert(sizeof(EquipSlotData) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/E/ExtraCellWaterType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ExtraCellWaterType : 8 | public BSExtraData // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ExtraCellWaterType }; 12 | static constexpr auto VTABLE{ VTABLE::ExtraCellWaterType }; 13 | static constexpr auto TYPE{ EXTRA_DATA_TYPE::kWaterType }; 14 | 15 | // members 16 | TESWaterForm* water; // 18 17 | }; 18 | static_assert(sizeof(ExtraCellWaterType) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/ExtraCharge.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ExtraCharge : 8 | public BSExtraData // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ExtraCharge }; 12 | static constexpr auto VTABLE{ VTABLE::ExtraCharge }; 13 | static constexpr auto TYPE{ EXTRA_DATA_TYPE::kCharge }; 14 | 15 | // members 16 | float charge; // 18 17 | }; 18 | static_assert(sizeof(ExtraCharge) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/ExtraFavorite.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ExtraFavorite : 8 | public BSExtraData // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ExtraFavorite }; 12 | static constexpr auto VTABLE{ VTABLE::ExtraFavorite }; 13 | static constexpr auto TYPE{ EXTRA_DATA_TYPE::kFavorite }; 14 | 15 | // members 16 | std::int8_t quickkeyIndex; //18 17 | }; 18 | static_assert(sizeof(ExtraFavorite) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/ExtraLocation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ExtraLocation : 8 | public BSExtraData // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ExtraLocation }; 12 | static constexpr auto VTABLE{ VTABLE::ExtraLocation }; 13 | static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLocation }; 14 | 15 | // members 16 | BGSLocation* location; // 18 17 | }; 18 | static_assert(sizeof(ExtraLocation) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/E/ExtraLock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class REFR_LOCK; 8 | 9 | class __declspec(novtable) ExtraLock : 10 | public BSExtraData // 00 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::ExtraLock }; 14 | static constexpr auto VTABLE{ VTABLE::ExtraLock }; 15 | static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLock }; 16 | 17 | // members 18 | REFR_LOCK* lock; // 18 19 | }; 20 | static_assert(sizeof(ExtraLock) == 0x20); 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/F/FACTION_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FACTION_DATA 6 | { 7 | public: 8 | // members 9 | std::uint32_t flags; // 0 10 | }; 11 | static_assert(sizeof(FACTION_DATA) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/F/FACTION_RANK.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FACTION_RANK 6 | { 7 | public: 8 | // members 9 | TESFaction* faction; // 00 10 | std::int8_t rank; // 08 11 | }; 12 | static_assert(sizeof(FACTION_RANK) == 0x10); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/F/FACTION_VENDOR_DATA_VALUES.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FACTION_VENDOR_DATA_VALUES 6 | { 7 | public: 8 | // members 9 | std::uint16_t startHour; // 0 10 | std::uint16_t endHour; // 2 11 | std::uint32_t locationRadius; // 4 12 | bool buysStolen; // 8 13 | bool notBuySell; // 9 14 | bool buysNonStolen; // A 15 | }; 16 | static_assert(sizeof(FACTION_VENDOR_DATA_VALUES) == 0xC); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/F/FIGHT_REACTION.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class FIGHT_REACTION : std::int32_t 6 | { 7 | kNeutral = 0x0, 8 | kEnemy = 0x1, 9 | kAlly = 0x2, 10 | kFriend = 0x3 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/F/FILE_HEADER.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FILE_HEADER 6 | { 7 | public: 8 | // members 9 | float version; // 0 10 | std::uint32_t formCount; // 4 11 | std::uint32_t nextFormID; // 8 12 | }; 13 | static_assert(sizeof(FILE_HEADER) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/F/FORM.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FORM 6 | { 7 | public: 8 | // members 9 | std::uint32_t form; // 00 10 | std::uint32_t length; // 04 11 | std::uint32_t flags; // 08 12 | TESFormID formID; // 0C 13 | std::uint32_t versionControl; // 10 14 | std::uint16_t formVersion; // 14 15 | std::uint16_t vcVersion; // 16 16 | }; 17 | static_assert(sizeof(FORM) == 0x18); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/F/FORM_ENUM_STRING.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/E/ENUM_FORM_ID.h" 4 | 5 | namespace RE 6 | { 7 | class FORM_ENUM_STRING 8 | { 9 | public: 10 | // members 11 | ENUM_FORM_ID formID; // 00 12 | const char* formString; // 08 - "GRUP" 13 | std::uint32_t formCode; // 10 - 'PURG' 14 | }; 15 | static_assert(sizeof(FORM_ENUM_STRING) == 0x18); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/F/FUNCTION_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class SCRIPT_OUTPUT; 6 | 7 | class FUNCTION_DATA 8 | { 9 | public: 10 | // members 11 | REX::EnumSet function; // 00 12 | void* param[2]; // 08 13 | }; 14 | static_assert(sizeof(FUNCTION_DATA) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/F/FatmanDeaths.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace FatmanDeaths 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | Actor* victim; // 00 12 | }; 13 | static_assert(sizeof(Event) == 0x8); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/F/FavoriteMgr_Events.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace FavoriteMgr_Events 6 | { 7 | class ComponentFavoriteEvent 8 | { 9 | public: 10 | // members 11 | BGSComponent* component; // 00 12 | bool isFavorited; // 08 13 | }; 14 | static_assert(sizeof(ComponentFavoriteEvent) == 0x10); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/F/FriendshipFactionsStruct.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class FriendshipFactionsStruct 6 | { 7 | public: 8 | // members 9 | std::uint16_t friendCounts[4]; // 0 10 | }; 11 | static_assert(sizeof(FriendshipFactionsStruct) == 0x8); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/G/GROUP_REACTION.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/F/FIGHT_REACTION.h" 4 | 5 | namespace RE 6 | { 7 | class GROUP_REACTION 8 | { 9 | public: 10 | // members 11 | TESForm* form; // 00 12 | std::int32_t reaction; // 08 13 | FIGHT_REACTION fightReaction; // 0C 14 | }; 15 | static_assert(sizeof(GROUP_REACTION) == 0x10); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/G/GUN_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class GUN_STATE : std::int32_t 6 | { 7 | kDrawn = 0x0, 8 | kRelaxed = 0x1, 9 | kBlocked = 0x2, 10 | kAlert = 0x3, 11 | kReloading = 0x4, 12 | kThrowing = 0x5, 13 | kSighted = 0x6, 14 | kFire = 0x7, 15 | kFireSighted = 0x8 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/G/GetCurrentPositionFunctor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class GetCurrentPositionFunctor 7 | { 8 | public: 9 | }; 10 | 11 | extern template class GetCurrentPositionFunctor; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/G/GridCell.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class GridCell 6 | { 7 | public: 8 | // members 9 | TESObjectCELL* cell; // 00 10 | }; 11 | static_assert(sizeof(GridCell) == 0x08); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/H/HUDColorTypes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class HUDColorTypes 6 | { 7 | kNoColorMultiplier = 0x0, 8 | kMenuNoColorBackground = 0x1, 9 | kGameplayHUDColor = 0x2, 10 | kPlayerSetColor = 0x3, 11 | kPowerArmorColorOnly = 0x4, 12 | kWarningColor = 0x5, 13 | kAltWarningColor = 0x6, 14 | kCustomColor = 0x7 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/H/HUDModeType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class HUDModeType 8 | { 9 | public: 10 | HUDModeType(const char* a_modeString) : 11 | modeString(a_modeString) 12 | {} 13 | 14 | // members 15 | BSFixedString modeString; // 0 16 | }; 17 | static_assert(sizeof(HUDModeType) == 0x8); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/H/HUDPerkVaultBoySwfDisplayEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | #include "RE/H/HUDPerkVaultBoyData.h" 5 | 6 | namespace RE 7 | { 8 | class HUDPerkVaultBoySwfDisplayEvent : 9 | public BSTValueEvent // 00 10 | { 11 | public: 12 | }; 13 | static_assert(sizeof(HUDPerkVaultBoySwfDisplayEvent) == 0x20); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/H/HolotapeStateChanged.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace HolotapeStateChanged 6 | { 7 | class Event 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/HourPassed.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace HourPassed 6 | { 7 | class Event 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkAabb.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkVector4f.h" 4 | 5 | namespace RE 6 | { 7 | class hkAabb 8 | { 9 | public: 10 | // members 11 | hkVector4f min; // 00 12 | hkVector4f max; // 10 13 | }; 14 | static_assert(sizeof(hkAabb) == 0x20); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/H/hkBaseObject.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkBaseObject 6 | { 7 | public: 8 | // add 9 | virtual ~hkBaseObject(); // 00 10 | virtual void __first_virtual_table_function__(); // 01 11 | }; 12 | static_assert(sizeof(hkBaseObject) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkBlockStream.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkBlockStreamBase.h" 4 | 5 | namespace RE 6 | { 7 | template 8 | class hkBlockStream : 9 | public hkBlockStreamBase::Stream 10 | { 11 | public: 12 | }; 13 | static_assert(sizeof(hkBlockStream) == 0x100); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/H/hkBool.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkBool 6 | { 7 | public: 8 | // members 9 | bool _bool; // 00 10 | }; 11 | static_assert(sizeof(hkBool) == 0x01); 12 | 13 | using hkBool32 = std::uint32_t; 14 | using hkBoolLL = std::uint64_t; 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/H/hkContainerHeapAllocator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkMemoryAllocator.h" 4 | 5 | namespace RE 6 | { 7 | class hkContainerHeapAllocator 8 | { 9 | public: 10 | class Allocator : 11 | public hkMemoryAllocator 12 | { 13 | public: 14 | }; 15 | static_assert(sizeof(Allocator) == 0x08); 16 | }; 17 | static_assert(std::is_empty_v); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/H/hkCriticalSection.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkCriticalSection 6 | { 7 | public: 8 | // members 9 | REX::W32::CRITICAL_SECTION section; // 00 10 | }; 11 | static_assert(sizeof(hkCriticalSection) == 0x28); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/H/hkEnum.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | using hkEnum = REX::EnumSet; 7 | } 8 | -------------------------------------------------------------------------------- /include/RE/H/hkFlags.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | using hkFlags = REX::EnumSet; 7 | } 8 | -------------------------------------------------------------------------------- /include/RE/H/hkHandle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class hkHandle 7 | { 8 | public: 9 | // members 10 | T value; // 00 11 | }; 12 | static_assert(sizeof(hkHandle) == 0x01); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkIntSpaceUtil.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkAabb.h" 4 | #include "RE/H/hkVector4f.h" 5 | 6 | namespace RE 7 | { 8 | class hkIntSpaceUtil 9 | { 10 | public: 11 | // members 12 | hkVector4f bitOffsetLow; // 00 13 | hkVector4f bitOffsetHigh; // 10 14 | hkVector4f bitScale; // 20 15 | hkVector4f bitScaleInv; // 30 16 | hkAabb aabb; // 40 17 | }; 18 | static_assert(sizeof(hkIntSpaceUtil) == 0x60); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/H/hkPadSpu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class hkPadSpu 7 | { 8 | public: 9 | // members 10 | T storage; // 00 11 | }; 12 | static_assert(sizeof(hkPadSpu) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkPtrAndInt.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class hkPtrAndInt 7 | { 8 | public: 9 | // members 10 | std::uint64_t ptrAndInt; // 00 11 | }; 12 | static_assert(sizeof(hkPtrAndInt) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkRefPtr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class hkRefPtr 7 | { 8 | public: 9 | // members 10 | T* ptr; // 00 11 | }; 12 | static_assert(sizeof(hkRefPtr) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/H/hkReferencedObject.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkBaseObject.h" 4 | 5 | namespace RE 6 | { 7 | class hkReferencedObject : 8 | public hkBaseObject 9 | { 10 | public: 11 | // members 12 | std::uint32_t memSizeAndRefCount; // 08 13 | }; 14 | static_assert(sizeof(hkReferencedObject) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/H/hkSimdFloat32.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkSimdFloat32 6 | { 7 | public: 8 | // members 9 | __m128 real; // 00 10 | }; 11 | static_assert(sizeof(hkSimdFloat32) == 0x10); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/H/hkSlot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkPtrAndInt.h" 4 | 5 | namespace RE 6 | { 7 | class hkSlot 8 | { 9 | public: 10 | // add 11 | virtual ~hkSlot(); // 00 12 | virtual std::uint32_t matchMethod(const void*, std::int32_t); // 01 13 | 14 | // members 15 | hkPtrAndInt next; // 08 16 | void* object; // 10 17 | }; 18 | static_assert(sizeof(hkSlot) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/H/hkStepInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkPadSpu.h" 4 | 5 | namespace RE 6 | { 7 | class hkStepInfo 8 | { 9 | public: 10 | // members 11 | hkPadSpu startTime; // 00 12 | hkPadSpu endTime; // 04 13 | hkPadSpu deltaTime; // 08 14 | hkPadSpu invDeltaTime; // 0C 15 | }; 16 | static_assert(sizeof(hkStepInfo) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/H/hkVector4f.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkVector4f 6 | { 7 | public: 8 | // members 9 | __m128 quad; // 00 10 | }; 11 | static_assert(sizeof(hkVector4f) == 0x10); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/H/hkcdRay.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkVector4f.h" 4 | 5 | namespace RE 6 | { 7 | class hkcdRay 8 | { 9 | public: 10 | // members 11 | hkVector4f origin; // 00 12 | hkVector4f direction; // 10 13 | hkVector4f invDirection; // 20 14 | }; 15 | static_assert(sizeof(hkcdRay) == 0x30); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/H/hkcdRayQueryFlags.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hkcdRayQueryFlags 6 | { 7 | public: 8 | enum class Enum; 9 | }; 10 | static_assert(std::is_empty_v); 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/H/hknpBodyId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/h/hkHandle.h" 4 | 5 | namespace RE 6 | { 7 | class hknpBodyIdBaseDiscriminant 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | 13 | class hknpBodyId : 14 | public hkHandle 15 | { 16 | public: 17 | }; 18 | static_assert(sizeof(hknpBodyId) == 0x04); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/H/hknpCharacterState.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkReferencedObject.h" 4 | 5 | namespace RE 6 | { 7 | class hknpCharacterState : 8 | public hkReferencedObject 9 | { 10 | public: 11 | enum class hknpCharacterStateType; 12 | }; 13 | static_assert(sizeof(hknpCharacterState) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/H/hknpCollisionQuery.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hknpQueryFilterData.h" 4 | 5 | namespace RE 6 | { 7 | class hknpCollisionFilter; 8 | 9 | class hknpCollisionQuery 10 | { 11 | public: 12 | // members 13 | hkPadSpu filter; // 00 14 | hknpQueryFilterData filterData; // 08 15 | std::uint8_t levelOfDetail; // 18 16 | }; 17 | static_assert(sizeof(hknpCollisionQuery) == 0x20); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/H/hknpCollisionQueryType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hknpCollisionQueryType 6 | { 7 | public: 8 | enum class Enum; 9 | }; 10 | static_assert(std::is_empty_v); 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/H/hknpConstraintIdDiscriminant.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hknpConstraintIdDiscriminant 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/H/hknpContactSolverType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class hknpContactSolverType 6 | { 7 | public: 8 | enum class Enum; 9 | }; 10 | static_assert(std::is_empty_v); 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/H/hknpMaterialId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkHandle.h" 4 | 5 | namespace RE 6 | { 7 | class hknpMaterialIdBaseDiscriminant 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | 13 | class hknpMaterialId : 14 | public hkHandle 15 | { 16 | public: 17 | }; 18 | static_assert(sizeof(hknpMaterialId) == 0x04); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/H/hknpMotionId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkHandle.h" 4 | 5 | namespace RE 6 | { 7 | class hknpMotionIdBaseDiscriminant 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | 13 | class hknpMotionId : 14 | public hkHandle 15 | { 16 | public: 17 | }; 18 | static_assert(sizeof(hknpMotionId) == 0x04); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/H/hknpMotionPropertiesId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkHandle.h" 4 | 5 | namespace RE 6 | { 7 | class hknpMotionPropertiesIdBaseDiscriminant 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | 13 | class hknpMotionPropertiesId : 14 | public hkHandle 15 | { 16 | public: 17 | enum class Preset; 18 | }; 19 | static_assert(sizeof(hknpMotionPropertiesId) == 0x02); 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/H/hknpQueryFilterData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hkPadSpu.h" 4 | #include "RE/H/hknpMaterialId.h" 5 | 6 | namespace RE 7 | { 8 | class hknpQueryFilterData 9 | { 10 | public: 11 | // members 12 | hknpMaterialId materialId; // 00 13 | hkPadSpu collisionFilterInfo; // 04 14 | hkPadSpu userData; // 08 15 | }; 16 | static_assert(sizeof(hknpQueryFilterData) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/H/hknpRayCastQueryResult.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/hknpCollisionResult.h" 4 | 5 | namespace RE 6 | { 7 | class hknpRayCastQueryResult : 8 | public hknpCollisionResult 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(hknpRayCastQueryResult) == 0x60); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/I/IDLE_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class IDLE_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t loopMin; // 0 10 | std::int8_t loopMax; // 1 11 | std::int8_t flags; // 2 12 | std::uint16_t replayDelay; // 4 13 | }; 14 | static_assert(sizeof(IDLE_DATA) == 0x6); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/I/IMovementInterface.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class __declspec(novtable) IMovementInterface 6 | { 7 | public: 8 | static constexpr auto RTTI{ RTTI::IMovementInterface }; 9 | static constexpr auto VTABLE{ VTABLE::IMovementInterface }; 10 | 11 | virtual ~IMovementInterface() = default; // 00 12 | }; 13 | static_assert(sizeof(IMovementInterface) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/I/INPUT_DEVICE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class INPUT_DEVICE : std::int32_t 6 | { 7 | kNone = static_cast>(-1), 8 | 9 | kKeyboard = 0, 10 | kMouse, 11 | kGamepad, 12 | 13 | kSupported, 14 | 15 | kKinect = 3, 16 | kVirtualKeyboard, 17 | 18 | kTotal 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/I/INPUT_DEVICE_LIGHT_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class INPUT_DEVICE_LIGHT_STATE : std::int32_t 6 | { 7 | kDeviceLightStatePowerArmorLight = 0x0, 8 | kDeviceLightStatePowerArmor = 0x1, 9 | kDeviceLightStatePipboyLight = 0x2, 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/I/INPUT_EVENT_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class INPUT_EVENT_TYPE : std::int32_t 6 | { 7 | kButton = 0x0, 8 | kMouseMove = 0x1, 9 | kCursorMove = 0x2, 10 | kChar = 0x3, 11 | kThumbstick = 0x4, 12 | kDeviceConnect = 0x5, 13 | kKinect = 0x6, 14 | kNone = 0x7 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/I/INTERACTING_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class INTERACTING_STATE : std::int32_t 6 | { 7 | kNotInteracting = 0x0, 8 | kWaitingToInteract = 0x1, 9 | kInteracting = 0x2, 10 | kWaitingToStopInteracting = 0x3 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/I/IPipboyThrottledValue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class IPipboyThrottledValue 6 | { 7 | public: 8 | static constexpr auto RTTI{ RTTI::IPipboyThrottledValue }; 9 | static constexpr auto VTABLE{ VTABLE::IPipboyThrottledValue }; 10 | 11 | // members 12 | virtual ~IPipboyThrottledValue(); // 00 13 | 14 | // add 15 | void* Update(); // 01 16 | }; 17 | static_assert(sizeof(IPipboyThrottledValue) == 0x8); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/I/ITEM_REMOVE_REASON.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ITEM_REMOVE_REASON : std::int32_t 6 | { 7 | kNone = 0x0, 8 | kStealing = 0x1, 9 | kSelling = 0x2, 10 | KDropping = 0x3, 11 | kStoreContainer = 0x4, 12 | kStoreTeammate = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/I/ImageSpaceData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/I/ImageSpaceBaseData.h" 4 | #include "RE/I/ImageSpaceModData.h" 5 | 6 | namespace RE 7 | { 8 | class ImageSpaceData 9 | { 10 | public: 11 | // members 12 | ImageSpaceBaseData baseData; //00 13 | ImageSpaceModData modData; //58 14 | float highestTintAmount; //A8 15 | float highestFadeAmount; //AC 16 | }; 17 | static_assert(sizeof(ImageSpaceData) == 0xB0); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/I/ImageSpaceEffectOption.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/I/ImageSpaceEffect.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ImageSpaceEffectOption : 8 | public ImageSpaceEffect // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ImageSpaceEffectOption }; 12 | static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectOption }; 13 | 14 | // members 15 | NiTPrimitiveArray effectOn; // B0 16 | }; 17 | static_assert(sizeof(ImageSpaceEffectOption) == 0xC8); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/I/ImageSpaceModifierFinder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class TESImageSpaceModifierForm; 8 | 9 | class ImageSpaceModifierFinder 10 | { 11 | public: 12 | // members 13 | TESImageSpaceModifierForm* modifier; // 00 14 | const BSFixedString& modifierToFind; // 08 15 | }; 16 | static_assert(sizeof(ImageSpaceModifierFinder) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/I/ImpactResult.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ImpactResult 6 | { 7 | kNone = 0x0, 8 | kDestroy = 0x1, 9 | kBounce = 0x2, 10 | kImpale = 0x3, 11 | kStick = 0x4 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/I/InventoryUserUIInterfaceEntry.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | #include "RE/I/InventoryInterface.h" 5 | 6 | namespace RE 7 | { 8 | class InventoryUserUIInterfaceEntry 9 | { 10 | public: 11 | // members 12 | InventoryInterface::Handle invHandle; // 00 13 | BSTSmallArray stackIndex; // 08 14 | }; 15 | static_assert(sizeof(InventoryUserUIInterfaceEntry) == 0x20); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/I/IsPipboyActiveEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class IsPipboyActiveEvent : 8 | public BSTValueEvent // 00 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(IsPipboyActiveEvent) == 0x02); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/L/LEVELED_OBJECT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class ContainerItemExtra; 6 | 7 | class LEVELED_OBJECT 8 | { 9 | public: 10 | // members 11 | TESForm* form; // 00 12 | ContainerItemExtra* itemExtra; // 08 13 | std::uint16_t count; // 10 14 | std::uint16_t level; // 12 15 | std::int8_t chanceNone; // 14 16 | }; 17 | static_assert(sizeof(LEVELED_OBJECT) == 0x18); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/L/LOCK_LEVEL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class LOCK_LEVEL : std::int32_t 6 | { 7 | kUnlocked = static_cast>(-1), 8 | kEasy = 0x0, 9 | kAverage = 0x1, 10 | kHard = 0x2, 11 | kVeryHard = 0x3, 12 | kRequiresKey = 0x4, 13 | kInaccessible = 0x5, 14 | kTerminal = 0x6, 15 | kBarred = 0x7, 16 | kChained = 0x8, 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/L/LoadingStatusChanged.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace LoadingStatusChanged 6 | { 7 | class Event 8 | { 9 | public: 10 | bool isLoading; // 00 11 | }; 12 | static_assert(sizeof(Event) == 0x1); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/L/LocalMapCameraUpdate.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace LocalMapCameraUpdate 6 | { 7 | class Event 8 | { 9 | public: 10 | }; 11 | static_assert(std::is_empty_v); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/L/LocationMarkerArrayUpdate.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace LocationMarkerArrayUpdate 6 | { 7 | class Event 8 | { 9 | public: 10 | bool shouldClearMapMarkers; // 00 11 | }; 12 | static_assert(sizeof(Event) == 0x1); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/M/MELEE_ATTACK_SPEED.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class MELEE_ATTACK_SPEED : std::int32_t 6 | { 7 | kVerySlow = 0x0, 8 | kSlow = 0x1, 9 | kMedium = 0x2, 10 | kFast = 0x3, 11 | kVeryFast = 0x4 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/M/MENU_RENDER_CONTEXT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class MENU_RENDER_CONTEXT : std::int32_t 6 | { 7 | kMenuDelete = 0x0, 8 | kPreDisplay = 0x1, 9 | kRenderScreenspace = 0x2, 10 | kRenderCopyQuads = 0x3, 11 | kRenderImagespace = 0x4, 12 | kEnsureDisplayMenuCalled = 0x5, 13 | kPostDisplay = 0x6 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/M/MESSAGEBOX_BUTTON.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSLocalizedString.h" 4 | #include "RE/T/TESCondition.h" 5 | 6 | namespace RE 7 | { 8 | class MESSAGEBOX_BUTTON 9 | { 10 | public: 11 | // members 12 | BGSLocalizedString text; // 00 13 | TESCondition conditions; // 08 14 | }; 15 | static_assert(sizeof(MESSAGEBOX_BUTTON) == 0x10); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/M/MOVABLE_STATIC_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class MOVABLE_STATIC_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t flags; // 0 10 | }; 11 | static_assert(sizeof(MOVABLE_STATIC_DATA) == 0x1); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/M/MeleeThrowHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/H/HeldStateHandler.h" 4 | 5 | namespace RE 6 | { 7 | class MeleeThrowHandler : 8 | public HeldStateHandler 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::MeleeThrowHandler }; 12 | static constexpr auto VTABLE{ VTABLE::MeleeThrowHandler }; 13 | 14 | // members 15 | bool buttonHoldDebounce; // 28 16 | bool pressRegistered; // 29 17 | bool queueThrow; // 2A 18 | }; 19 | static_assert(sizeof(MeleeThrowHandler) == 0x30); 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/M/MenuModeChangeEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class MenuModeChangeEvent 8 | { 9 | public: 10 | // members 11 | BSFixedString menuName; // 00 12 | bool enteringMenuMode; // 08 13 | }; 14 | static_assert(sizeof(MenuModeChangeEvent) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/M/MenuModeCounterChangedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class MenuModeCounterChangedEvent 8 | { 9 | public: 10 | // members 11 | BSFixedString menuName; // 00 12 | bool incrementing; // 08 13 | }; 14 | static_assert(sizeof(MenuModeCounterChangedEvent) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/M/MenuOpenCloseEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class MenuOpenCloseEvent 8 | { 9 | public: 10 | // members 11 | BSFixedString menuName; // 00 12 | bool opening; // 08 13 | }; 14 | static_assert(sizeof(MenuOpenCloseEvent) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/M/MenuOpenHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSInputEventUser.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) MenuOpenHandler : 8 | public BSInputEventUser // 00 9 | { 10 | static constexpr auto RTTI{ RTTI::MenuOpenHandler }; 11 | static constexpr auto VTABLE{ VTABLE::MenuOpenHandler }; 12 | }; 13 | static_assert(sizeof(MenuOpenHandler) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/M/MiddleLowProcessData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class MiddleLowProcessData 6 | { 7 | public: 8 | // members 9 | std::int32_t hourPackageEvaluated; // 0 10 | }; 11 | static_assert(sizeof(MiddleLowProcessData) == 0x4); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/M/Modifiers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class Modifiers 6 | { 7 | public: 8 | // members 9 | float modifiers[3]; // 0 10 | }; 11 | static_assert(sizeof(Modifiers) == 0xC); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/M/MovementData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class MovementData 8 | { 9 | public: 10 | // members 11 | NiPoint3A movementRotation; // 00 12 | NiPoint3A rotationSpeed; // 10 13 | float movementSpeed; // 20 14 | }; 15 | static_assert(sizeof(MovementData) == 0x30); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/N/NPC_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NPC_DATA 6 | { 7 | public: 8 | // members 9 | std::int16_t autoCalcHealth; // 0 10 | std::int16_t autoCalcActionPoints; // 2 11 | std::uint16_t farDistance; // 4 12 | std::int8_t gearedUpWeapons; // 6 13 | }; 14 | static_assert(sizeof(NPC_DATA) == 0x8); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/N/NiBound.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class NiBound 8 | { 9 | public: 10 | // members 11 | NiPoint3 center; // 00 12 | union 13 | { 14 | float fRadius; 15 | std::int32_t iRadius{ 0 }; 16 | }; // 0C 17 | }; 18 | static_assert(sizeof(NiBound) == 0x10); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/N/NiColor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiColor 6 | { 7 | public: 8 | // members 9 | float r; // 0 10 | float g; // 4 11 | float b; // 8 12 | }; 13 | static_assert(sizeof(NiColor) == 0xC); 14 | 15 | class NiColorA 16 | { 17 | public: 18 | // members 19 | float r; // 0 20 | float g; // 4 21 | float b; // 8 22 | float a; // C 23 | }; 24 | static_assert(sizeof(NiColorA) == 0x10); 25 | } 26 | -------------------------------------------------------------------------------- /include/RE/N/NiExtraDataContainer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSSpinLock.h" 4 | #include "RE/B/BSTArray.h" 5 | 6 | namespace RE 7 | { 8 | class NiExtraData; 9 | 10 | class NiExtraDataContainer : 11 | public BSTArray 12 | { 13 | public: 14 | BSAutoLock lock; 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/N/NiFrustum.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiFrustum 6 | { 7 | public: 8 | float left; // 00 9 | float right; // 04 10 | float top; // 08 11 | float bottom; // 0C 12 | float near; // 10 13 | float far; // 14 14 | bool ortho; // 18 15 | }; 16 | static_assert(sizeof(NiFrustum) == 0x1C); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/N/NiNPShortPoint3.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiNPShortPoint3 6 | { 7 | public: 8 | // members 9 | std::int16_t x; // 0 10 | std::int16_t y; // 2 11 | std::int16_t z; // 4 12 | }; 13 | static_assert(sizeof(NiNPShortPoint3) == 0x6); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/N/NiQuaternion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiQuaternion 6 | { 7 | public: 8 | float w; // 00 9 | float x; // 04 10 | float y; // 08 11 | float z; // 0C 12 | }; 13 | static_assert(sizeof(NiQuaternion) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/N/NiRect.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class NiRect 7 | { 8 | public: 9 | // members 10 | T left; // 00 11 | T right; // ?? 12 | T top; // ?? 13 | T bottom; // ?? 14 | }; 15 | 16 | extern template class NiRect; 17 | extern template class NiRect; 18 | extern template class NiRect; 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/N/NiStringExtraData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiExtraData.h" 4 | 5 | namespace RE 6 | { 7 | class NiStringExtraData : 8 | public NiExtraData 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::NiStringExtraData }; 12 | static constexpr auto VTABLE{ VTABLE::NiStringExtraData }; 13 | static constexpr auto Ni_RTTI{ Ni_RTTI::NiStringExtraData }; 14 | 15 | // members 16 | BSFixedString data; // 18 17 | }; 18 | static_assert(sizeof(NiStringExtraData) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/N/NiTDefaultAllocator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class DFALL 7 | { 8 | public: 9 | }; 10 | 11 | template 12 | using NiTDefaultAllocator = DFALL; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/N/NiTFlags.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | template 6 | class NiTFlags 7 | { 8 | public: 9 | using integral_type = Integral; 10 | 11 | static_assert(std::is_integral_v); 12 | 13 | constexpr NiTFlags() noexcept {} // NOLINT(moderinize-use-equals-default) 14 | 15 | // members 16 | integral_type flags{ 0 }; // 00 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/N/NiTPointerAllocator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerAllocator.h" 4 | 5 | namespace RE 6 | { 7 | template 8 | class NiTPointerAllocator : 9 | public BSPointerAllocator // 0 10 | { 11 | public: 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/N/NiUpdateData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class NiCamera; 6 | 7 | class NiUpdateData 8 | { 9 | public: 10 | // members 11 | float time{ 0.0f }; // 00 12 | NiCamera* camera{ nullptr }; // 08 13 | std::uint32_t flags{ 0 }; // 10 14 | std::uint32_t renderObjects{ 0 }; // 14 15 | std::uint32_t fadeNodeDepth{ 0 }; // 18 16 | }; 17 | static_assert(sizeof(NiUpdateData) == 0x20); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/N/nsStatsMenuUtils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace nsStatsMenuUtils 6 | { 7 | inline void GetEffectDisplayInfo(MagicItem* a_item, EffectItem* a_effect, float& a_magnitude, float& a_duration) 8 | { 9 | using func_t = decltype(&nsStatsMenuUtils::GetEffectDisplayInfo); 10 | static REL::Relocation func{ ID::nsStatsMenuUtils::GetEffectDisplayInfo }; 11 | return func(a_item, a_effect, a_magnitude, a_duration); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/O/OBJ_ARMA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class OBJ_ARMA 6 | { 7 | public: 8 | // members 9 | std::int8_t priorities[2]; // 0 10 | std::int8_t modelRange[2]; // 2 11 | std::int8_t unused[2]; // 4 12 | std::int8_t soundValue; // 6 13 | float weaponAdjust; // 8 14 | }; 15 | static_assert(sizeof(OBJ_ARMA) == 0xC); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/O/OBJ_BOOK.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class OBJ_BOOK 6 | { 7 | public: 8 | union Teaches 9 | { 10 | ActorValueInfo* actorValueToAdvance; 11 | SpellItem* spell; 12 | BGSPerk* perk; 13 | }; 14 | static_assert(sizeof(Teaches) == 0x8); 15 | 16 | // members 17 | std::int8_t flags; // 00 18 | Teaches teaches; // 08 19 | std::uint32_t textOffsetX; // 10 20 | std::uint32_t textOffsetY; // 14 21 | }; 22 | static_assert(sizeof(OBJ_BOOK) == 0x18); 23 | } 24 | -------------------------------------------------------------------------------- /include/RE/O/OBJ_REFR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPoint.h" 4 | 5 | namespace RE 6 | { 7 | class OBJ_REFR 8 | { 9 | public: 10 | // members 11 | NiPoint3A angle; // 00 12 | NiPoint3A location; // 10 13 | TESBoundObject* objectReference; // 20 14 | }; 15 | static_assert(sizeof(OBJ_REFR) == 0x30); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/P/PACKAGE_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PACKAGE_DATA 6 | { 7 | public: 8 | // members 9 | std::uint32_t packFlags; // 0 10 | std::int8_t packType; // 4 11 | std::int8_t interruptOverrideType; // 5 12 | std::int8_t maxSpeed; // 6 13 | std::uint16_t foBehaviorFlags; // 8 14 | std::uint16_t packageSpecificFlags; // A 15 | }; 16 | static_assert(sizeof(PACKAGE_DATA) == 0xC); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/P/PACK_SCHED_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PACK_SCHED_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t month; // 0 10 | std::int8_t dayOfWeek; // 1 11 | std::int8_t date; // 2 12 | std::int8_t hour; // 3 13 | std::int8_t min; // 4 14 | std::int32_t duration; // 8 15 | }; 16 | static_assert(sizeof(PACK_SCHED_DATA) == 0xC); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/P/PATH_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PATH_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t flags; // 0 10 | }; 11 | static_assert(sizeof(PATH_DATA) == 0x1); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/P/PC_GAMEPAD_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class PC_GAMEPAD_TYPE : std::int32_t 6 | { 7 | kDirectX = 0x0, 8 | kOrbis = 0x1, 9 | 10 | kTotal 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/P/PIPBOY_PAGES.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class PIPBOY_PAGES : std::int32_t 6 | { 7 | kStat = 0x0, 8 | kInv = 0x1, 9 | kData = 0x2, 10 | kMap = 0x3, 11 | kRadio = 0x4 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/P/POWER_ARMOR_HUD_VISIBILITY_RULE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class POWER_ARMOR_HUD_VISIBILITY_RULE : std::int32_t 6 | { 7 | kIgnoresPAHUDVisibility = 0x0, 8 | kOnlyWithPAHUDVisible = 0x1, 9 | kOnlyWithPAHUDNotVisible = 0x2 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/P/PackageList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSSimpleList.h" 4 | 5 | namespace RE 6 | { 7 | class PackageList 8 | { 9 | public: 10 | // members 11 | BSSimpleList listPackages; 12 | }; 13 | static_assert(sizeof(PackageList) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PackageSchedule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/P/PACK_SCHED_DATA.h" 4 | 5 | namespace RE 6 | { 7 | class PackageSchedule 8 | { 9 | public: 10 | // members 11 | PACK_SCHED_DATA psData; // 0 12 | }; 13 | static_assert(sizeof(PackageSchedule) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PerkAdded.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace PerkAdded 6 | { 7 | class Event 8 | { 9 | public: 10 | const Actor* adder; 11 | const BGSPerk* perk; 12 | std::uint8_t rank; 13 | }; 14 | static_assert(sizeof(Event) == 0x18); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/P/PerkData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PerkData 6 | { 7 | public: 8 | // members 9 | bool trait; // 0 10 | std::int8_t level; // 1 11 | std::int8_t numRanks; // 2 12 | bool playable; // 3 13 | bool hidden; // 4 14 | }; 15 | static_assert(sizeof(PerkData) == 0x5); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/P/PerkRankData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/M/MemoryManager.h" 4 | 5 | namespace RE 6 | { 7 | class PerkRankData 8 | { 9 | public: 10 | PerkRankData(BGSPerk* a_perk, std::int8_t a_rank) : 11 | perk(a_perk), currentRank(a_rank) 12 | {} 13 | 14 | F4_HEAP_REDEFINE_NEW(PerkRankData); 15 | 16 | // members 17 | BGSPerk* perk; // 00 18 | std::int8_t currentRank; // 08 19 | }; 20 | static_assert(sizeof(PerkRankData) == 0x10); 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/P/PerkUtilities.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace PerkUtilities 6 | { 7 | inline void RemoveGrenadeTrajectory() 8 | { 9 | using func_t = decltype(&RemoveGrenadeTrajectory); 10 | static REL::Relocation func{ ID::PerkUtilities::RemoveGrenadeTrajectory }; 11 | return func(); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PersistentPassList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class BSRenderPass; 6 | 7 | class PersistentPassList 8 | { 9 | public: 10 | // members 11 | BSRenderPass* head; // 00 12 | BSRenderPass* tail; // 08 13 | }; 14 | static_assert(sizeof(PersistentPassList) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/P/PipboyRadioController.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PipboyRadioController 6 | { 7 | public: 8 | // members 9 | float chaseStation; // 00 10 | }; 11 | static_assert(sizeof(PipboyRadioController) == 0x04); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/P/PipboyThrottleManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTHashMap.h" 4 | #include "RE/I/IPipboyThrottledValue.h" 5 | 6 | namespace RE 7 | { 8 | class PipboyThrottleManager 9 | { 10 | public: 11 | BSTHashMap valueMap; // 00 12 | }; 13 | static_assert(sizeof(PipboyThrottleManager) == 0x30); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PlayerAddicted.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace PlayerAddicted 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | const AlchemyItem* chem; // 00 12 | }; 13 | static_assert(sizeof(Event) == 0x8); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/P/PlayerAmmoCountEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | #include "RE/P/PlayerAmmoCounts.h" 5 | 6 | namespace RE 7 | { 8 | class PlayerAmmoCountEvent : 9 | public BSTValueEvent 10 | { 11 | public: 12 | }; 13 | static_assert(sizeof(PlayerAmmoCountEvent) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PlayerAmmoCounts.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PlayerAmmoCounts 6 | { 7 | public: 8 | // members 9 | std::uint32_t clipAmmo; // 00 10 | std::uint32_t reserveAmmo; // 04 11 | }; 12 | static_assert(sizeof(PlayerAmmoCounts) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/P/PlayerAutoAimActorEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerHandle.h" 4 | #include "RE/B/BSTEvent.h" 5 | 6 | namespace RE 7 | { 8 | class PlayerAutoAimActorEvent : 9 | public BSTValueEvent // 0 10 | { 11 | public: 12 | }; 13 | static_assert(sizeof(PlayerAutoAimActorEvent) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/P/PlayerCommandTypeEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | enum class COMMAND_TYPE; 8 | 9 | class PlayerCommandTypeEvent : 10 | public BSTValueEvent // 0 11 | { 12 | public: 13 | }; 14 | static_assert(sizeof(PlayerCommandTypeEvent) == 0x8); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/P/PlayerControlsMovementData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/M/MovementData.h" 4 | #include "RE/N/NiPoint.h" 5 | 6 | namespace RE 7 | { 8 | class PlayerControlsMovementData : 9 | public MovementData // 00 10 | { 11 | public: 12 | // members 13 | NiPoint3A targetAngle; // 30 14 | }; 15 | static_assert(sizeof(PlayerControlsMovementData) == 0x40); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/P/PlayerDifficultySettingChanged.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace PlayerDifficultySettingChanged 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | std::uint32_t oldDifficulty; // 00 12 | std::uint32_t newDifficulty; // 04 13 | }; 14 | static_assert(sizeof(Event) == 0x8); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/P/PlayerInDialogueChanged.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace PlayerInDialogueChanged 6 | { 7 | class Event 8 | { 9 | public: 10 | // members 11 | bool isPlayerInDialogue; // 00 12 | }; 13 | static_assert(sizeof(Event) == 0x1); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/P/PlayerLifeStateChanged.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class ACTOR_LIFE_STATE; 6 | 7 | namespace PlayerLifeStateChanged 8 | { 9 | class Event 10 | { 11 | public: 12 | // members 13 | ACTOR_LIFE_STATE lifeState; // 00 14 | }; 15 | static_assert(sizeof(Event) == 0x4); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/P/PlayerUpdateEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class PlayerUpdateEvent 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/P/PlayerWeaponReloadEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class PlayerWeaponReloadEvent : 8 | public BSTValueEvent 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(PlayerWeaponReloadEvent) == 0x2); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/P/PrecomputedNavmeshInfoPathMap.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPrecomputedNavmeshInfoPathMap.h" 4 | 5 | namespace RE 6 | { 7 | class PrecomputedNavmeshInfoPathMap : 8 | public BSPrecomputedNavmeshInfoPathMap // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::PrecomputedNavmeshInfoPathMap }; 12 | }; 13 | static_assert(sizeof(PrecomputedNavmeshInfoPathMap) == 0x48); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/Q/QUEST_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class QUEST_DATA 6 | { 7 | public: 8 | // members 9 | float questDelayTime; // 00 10 | std::uint16_t flags; // 04 11 | std::int8_t priority; // 06 12 | std::int8_t questType; // 07 13 | }; 14 | static_assert(sizeof(QUEST_DATA) == 0x8); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/Q/QUEST_OBJECTIVE_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class QUEST_OBJECTIVE_STATE : std::int32_t 6 | { 7 | kDormant = 0x0, 8 | kDisplayed = 0x1, 9 | kCompleted = 0x2, 10 | kCompletedDisplayed = 0x3, 11 | kFailed = 0x4, 12 | kFailedDisplayed = 0x5, 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/Q/QuickContainerMode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class QuickContainerMode : std::int32_t 6 | { 7 | kLoot = 0x0, 8 | kTeammate = 0x1, 9 | kPowerArmor = 0x2, 10 | kTurret = 0x3, 11 | kWorkshop = 0x4, 12 | kCrafting = 0x5, 13 | kStealing = 0x6, 14 | kStealingPowerArmor = 0x7 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/Q/QuickContainerStateEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | #include "RE/Q/QuickContainerStateData.h" 5 | 6 | namespace RE 7 | { 8 | class QuickContainerStateEvent : 9 | public BSTValueEvent // 00 10 | { 11 | public: 12 | }; 13 | static_assert(sizeof(QuickContainerStateEvent) == 0xC0); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/R/RACE_SIZE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class RACE_SIZE : std::int32_t 6 | { 7 | kSmall = 0x0, 8 | kMedium = 0x1, 9 | kLarge = 0x2, 10 | kExtraLarge = 0x2 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/R/RANK_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BGSLocalizedString.h" 4 | #include "RE/T/TESTexture.h" 5 | 6 | namespace RE 7 | { 8 | class RANK_DATA 9 | { 10 | public: 11 | // members 12 | BGSLocalizedString maleRankTitle; // 00 13 | BGSLocalizedString femaleRankTitle; // 08 14 | TESTexture textureInsignia; // 10 15 | }; 16 | static_assert(sizeof(RANK_DATA) == 0x20); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/R/RESET_3D_FLAGS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class RESET_3D_FLAGS : std::int32_t 6 | { 7 | kModel = 1u << 0, 8 | kSkin = 1u << 1, 9 | kHead = 1u << 2, 10 | kFace = 1u << 3, 11 | kScale = 1u << 4, 12 | kSkeleton = 1u << 5, 13 | kInitDefault = 1u << 6, 14 | kSkyCellSkin = 1u << 7, 15 | kHavok = 1u << 8, 16 | kDontAddOutfit = 1u << 9, 17 | kKeepHead = 1u << 10, 18 | kDismemberment = 1u << 11 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/R/RepeaterData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace TESSoundDefs 6 | { 7 | class RepeaterData 8 | { 9 | public: 10 | // members 11 | float minDelay; // 0 12 | float maxDelay; // 4 13 | bool stackable; // 8 14 | }; 15 | static_assert(sizeof(RepeaterData) == 0xC); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/R/ResponseListWrapper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESResponse; 6 | 7 | class ResponseListWrapper 8 | { 9 | public: 10 | // members 11 | TESResponse* head; // 0 12 | }; 13 | static_assert(sizeof(ResponseListWrapper) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/R/Rumble.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class Rumble 6 | { 7 | public: 8 | class AutoRumblePause 9 | { 10 | public: 11 | }; 12 | static_assert(std::is_empty_v); 13 | }; 14 | static_assert(std::is_empty_v); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/S/SCRIPT_EFFECT_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SCRIPT_EFFECT_DATA 6 | { 7 | public: 8 | // members 9 | bool scriptEffectStart; // 0 10 | bool scriptEffectFinish; // 1 11 | float secondsElapsed; // 4 12 | }; 13 | static_assert(sizeof(SCRIPT_EFFECT_DATA) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/S/SCRIPT_HEADER.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SCRIPT_HEADER 6 | { 7 | public: 8 | // members 9 | std::uint32_t variableCount; // 00 10 | std::uint32_t refObjectCount; // 04 11 | std::uint32_t dataSize; // 08 12 | std::uint32_t lastID; // 0C 13 | bool isQuestScript; // 10 14 | bool isMagicEffectScript; // 11 15 | bool isCompiled; // 12 16 | }; 17 | static_assert(sizeof(SCRIPT_HEADER) == 0x14); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/S/SCRIPT_LOCAL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SCRIPT_LOCAL 6 | { 7 | public: 8 | // members 9 | std::uint32_t id; // 0 10 | float value; // 4 11 | bool isInteger; // 8 12 | }; 13 | static_assert(sizeof(SCRIPT_LOCAL) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/S/SCRIPT_PARAMETER.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class SCRIPT_PARAM_TYPE; 6 | 7 | class SCRIPT_PARAMETER 8 | { 9 | public: 10 | // members 11 | const char* paramName{ "" }; // 00 12 | REX::EnumSet paramType; // 08 13 | bool optional{ false }; // 0C 14 | }; 15 | static_assert(sizeof(SCRIPT_PARAMETER) == 0x10); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/S/SCRIPT_REFERENCED_OBJECT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSStringT.h" 4 | 5 | namespace RE 6 | { 7 | class SCRIPT_REFERENCED_OBJECT 8 | { 9 | public: 10 | // members 11 | BSString editorID; // 00 12 | TESForm* form; // 10 13 | std::uint32_t variableID; // 18 14 | }; 15 | static_assert(sizeof(SCRIPT_REFERENCED_OBJECT) == 0x20); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/S/SFRendererInitializedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SFRendererInitializedEvent 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/S/SIT_SLEEP_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class SIT_SLEEP_STATE : std::int32_t 6 | { 7 | kNormal = 0x0, 8 | kWantToSit = 0x1, 9 | kWaitingForSitAnim = 0x2, 10 | kIsSitting = 0x3, 11 | kWantToStand = 0x4, 12 | kWantToSleep = 0x5, 13 | kWaitingForSleepAnim = 0x6, 14 | kIsSleeping = 0x7, 15 | kWantToWake = 0x8 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/S/SOUND_LEVEL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class SOUND_LEVEL : std::int32_t 6 | { 7 | kLoud = 0x0, 8 | kNormal = 0x1, 9 | kSilent = 0x2, 10 | kVeryLoud = 0x3, 11 | kQuiet = 0x4, 12 | kCount = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/S/SPECIALMenuEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace SPECIALMenuEvent 6 | { 7 | class NameChangedEvent 8 | { 9 | public: 10 | // members 11 | const char* fullName; // 00 12 | bool committed; // 08 13 | }; 14 | static_assert(sizeof(NameChangedEvent) == 0x10); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/S/SayOnceTimeStampStruct.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SayOnceTimeStampStruct 6 | { 7 | public: 8 | // members 9 | std::uint32_t date; // 0 10 | float hour; // 4 11 | }; 12 | static_assert(sizeof(SayOnceTimeStampStruct) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/S/ScreenshotHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSInputEventUser.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) ScreenshotHandler : 8 | public BSInputEventUser // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::ScreenshotHandler }; 12 | static constexpr auto VTABLE{ VTABLE::ScreenshotHandler }; 13 | 14 | // members 15 | bool screenshotQueued; // 10 16 | bool multiScreenshotQueued; // 11 17 | }; 18 | static_assert(sizeof(ScreenshotHandler) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/S/ScriptCompiler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class ScriptCompiler 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/RE/S/ScriptVariable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSStringT.h" 4 | #include "RE/S/SCRIPT_LOCAL.h" 5 | 6 | namespace RE 7 | { 8 | class ScriptVariable 9 | { 10 | public: 11 | // members 12 | SCRIPT_LOCAL data; // 00 13 | BSString name; // 10 14 | }; 15 | static_assert(sizeof(ScriptVariable) == 0x20); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/S/SetCullMarkersFunctor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SetCullMarkersFunctor 6 | { 7 | public: 8 | // members 9 | bool cull; // 00 10 | }; 11 | static_assert(sizeof(SetCullMarkersFunctor) == 0x1); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/S/ShowingDialogueSpeechChallengeAnim.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class ShowingDialogueSpeechChallengeAnim : 8 | public BSTValueEvent 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(ShowingDialogueSpeechChallengeAnim) == 0x2); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/S/SneakHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/P/PlayerInputHandler.h" 4 | 5 | namespace RE 6 | { 7 | class SneakHandler : 8 | public PlayerInputHandler 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::SneakHandler }; 12 | static constexpr auto VTABLE{ VTABLE::SneakHandler }; 13 | 14 | explicit constexpr SneakHandler(PlayerControlsData& a_data) noexcept : 15 | PlayerInputHandler(a_data) 16 | {} 17 | }; 18 | static_assert(sizeof(SneakHandler) == 0x20); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/S/SpecialRefData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/U/UnloadedRefData.h" 4 | 5 | namespace RE 6 | { 7 | class SpecialRefData 8 | { 9 | public: 10 | // members 11 | BGSLocationRefType* type; // 00 12 | UnloadedRefData refData; // 08 13 | }; 14 | static_assert(sizeof(SpecialRefData) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/S/StolenItemValueStruct.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class StolenItemValueStruct 6 | { 7 | public: 8 | // members 9 | std::uint32_t stolenItemValueNoCrime; // 0 10 | std::uint32_t istolenItemValueCrime; // 4 11 | }; 12 | static_assert(sizeof(StolenItemValueStruct) == 0x8); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/S/SubGraphIdleRootData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | #include "RE/S/SubgraphIdentifier.h" 5 | 6 | namespace RE 7 | { 8 | class SubGraphIdleRootData 9 | { 10 | public: 11 | // members 12 | SubgraphIdentifier subGraphID; // 00 13 | BSFixedString idleRootName; // 08 14 | std::int8_t count; // 10 15 | std::int8_t activeCount; // 11 16 | bool forFirstPerson; // 12 17 | }; 18 | static_assert(sizeof(SubGraphIdleRootData) == 0x18); 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/S/SubgraphHandle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SubgraphHandle 6 | { 7 | public: 8 | // members 9 | std::uint64_t handle; // 0 10 | }; 11 | static_assert(sizeof(SubgraphHandle) == 0x8); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/S/SubgraphIdentifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class SubgraphIdentifier 6 | { 7 | public: 8 | // members 9 | std::size_t identifier; // 0 10 | }; 11 | static_assert(sizeof(SubgraphIdentifier) == 0x8); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/T/TEMP_EFFECT_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class TEMP_EFFECT_TYPE : std::int32_t 6 | { 7 | kTerrain = 0x0, 8 | kWeaponBlood = 0x1, 9 | kDecal = 0x2, 10 | kGeometryDecal = 0x3, 11 | kParticle = 0x4, 12 | kDebris = 0x5, 13 | kSPG = 0x6, 14 | kDefault = 0x7, 15 | kRefDefault = 0x8, 16 | kRefModel = 0x9, 17 | kRefShader = 0xA, 18 | kMagicSummon = 0xB 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /include/RE/T/TESBoundAnimObject.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESBoundObject.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESBoundAnimObject : 8 | public TESBoundObject // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESBoundAnimObject }; 12 | static constexpr auto VTABLE{ VTABLE::TESBoundAnimObject }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kNONE }; 14 | }; 15 | static_assert(sizeof(TESBoundAnimObject) == 0x68); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/T/TESChildCell.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class __declspec(novtable) TESChildCell 6 | { 7 | public: 8 | static constexpr auto RTTI{ RTTI::TESChildCell }; 9 | static constexpr auto VTABLE{ VTABLE::TESChildCell }; 10 | 11 | virtual ~TESChildCell() = default; // 00 12 | 13 | // add 14 | virtual TESObjectCELL* GetSaveParentCell() const = 0; // 01 15 | }; 16 | static_assert(sizeof(TESChildCell) == 0x8); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/T/TESEquipEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/N/NiPointer.h" 4 | 5 | namespace RE 6 | { 7 | class TESEquipEvent 8 | { 9 | public: 10 | // members 11 | NiPointer actor; // 00 12 | std::uint32_t baseObject; // 08 13 | std::uint32_t originalRefr; // 0C 14 | std::uint16_t uniqueID; // 10 15 | bool equipped; // 12 16 | }; 17 | static_assert(sizeof(TESEquipEvent) == 0x18); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESFileArray.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | 5 | namespace RE 6 | { 7 | class TESFile; 8 | 9 | class TESFileArray : 10 | public BSStaticArray // 00 11 | { 12 | public: 13 | }; 14 | static_assert(sizeof(TESFileArray) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESFileCollection.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTArray.h" 4 | 5 | namespace RE 6 | { 7 | class TESFile; 8 | 9 | class TESFileCollection 10 | { 11 | public: 12 | // members 13 | BSTArray files; // 00 14 | BSTArray smallFiles; // 18 15 | }; 16 | static_assert(sizeof(TESFileCollection) == 0x30); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/T/TESFileContainer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESFileArray; 6 | 7 | class TESFileContainer 8 | { 9 | public: 10 | // members 11 | const TESFileArray* array; // 0 12 | }; 13 | static_assert(sizeof(TESFileContainer) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/T/TESFlora.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESObjectACTI.h" 4 | #include "RE/T/TESProduceForm.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) TESFlora : 9 | public TESObjectACTI, // 000 10 | public TESProduceForm // 148 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::TESFlora }; 14 | static constexpr auto VTABLE{ VTABLE::TESFlora }; 15 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kFLOR }; 16 | }; 17 | static_assert(sizeof(TESFlora) == 0x168); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESIcon.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESTexture.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESIcon : 8 | public TESTexture // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESIcon }; 12 | static constexpr auto VTABLE{ VTABLE::TESIcon }; 13 | }; 14 | static_assert(sizeof(TESIcon) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESKey.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESObjectMISC.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESKey : 8 | public TESObjectMISC // 000 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESKey }; 12 | static constexpr auto VTABLE{ VTABLE::TESKey }; 13 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kKEYM }; 14 | }; 15 | static_assert(sizeof(TESKey) == 0x168); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/T/TESLevItem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESBoundObject.h" 4 | #include "RE/T/TESLeveledList.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) TESLevItem : 9 | public TESBoundObject, // 00 10 | public TESLeveledList // 68 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::TESLevItem }; 14 | static constexpr auto VTABLE{ VTABLE::TESLevItem }; 15 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kLVLI }; 16 | }; 17 | static_assert(sizeof(TESLevItem) == 0x98); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESLevSpell.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESBoundObject.h" 4 | #include "RE/T/TESLeveledList.h" 5 | 6 | namespace RE 7 | { 8 | class __declspec(novtable) TESLevSpell : 9 | public TESBoundObject, // 00 10 | public TESLeveledList // 68 11 | { 12 | public: 13 | static constexpr auto RTTI{ RTTI::TESLevSpell }; 14 | static constexpr auto VTABLE{ VTABLE::TESLevSpell }; 15 | static constexpr auto FORM_ID{ ENUM_FORM_ID::kLVSP }; 16 | }; 17 | static_assert(sizeof(TESLevSpell) == 0x98); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESLoadGameEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSTEvent.h" 4 | 5 | namespace RE 6 | { 7 | class TESLoadGameEvent 8 | { 9 | public: 10 | [[nodiscard]] static BSTEventSource* GetEventSource() 11 | { 12 | using func_t = decltype(&TESLoadGameEvent::GetEventSource); 13 | static REL::Relocation func{ ID::TESLoadGameEvent::GetEventSource }; 14 | return func(); 15 | } 16 | }; 17 | static_assert(sizeof(TESLoadGameEvent) == 0x1); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESLocationClearedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESLocationClearedEvent 6 | { 7 | public: 8 | // members 9 | const BGSLocation* location; // 00 10 | }; 11 | static_assert(sizeof(TESLocationClearedEvent) == 0x08); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/T/TESMagicCasterForm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESMagicCasterForm 6 | { 7 | public: 8 | static constexpr auto RTTI{ RTTI::TESMagicCasterForm }; 9 | }; 10 | static_assert(std::is_empty_v); 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/T/TESMagicTargetForm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESMagicTargetForm 6 | { 7 | public: 8 | static constexpr auto RTTI{ RTTI::TESMagicTargetForm }; 9 | }; 10 | static_assert(std::is_empty_v); 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/T/TESModelRDT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESModel.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESModelRDT : 8 | public TESModel // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESModelRDT }; 12 | static constexpr auto VTABLE{ VTABLE::TESModelRDT }; 13 | }; 14 | static_assert(sizeof(TESModelRDT) == 0x30); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESModelTri.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESModel.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESModelTri : 8 | public TESModel // 00 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESModelTri }; 12 | static constexpr auto VTABLE{ VTABLE::TESModelTri }; 13 | }; 14 | static_assert(sizeof(TESModelTri) == 0x30); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESObjectSTATData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TESObjectSTATData 6 | { 7 | public: 8 | // members 9 | BGSMaterialObject* materialObj; // 00 10 | float materialThresholdAngle; // 08 11 | float leafAmplitude; // 0C 12 | float leafFrequency; // 10 13 | }; 14 | static_assert(sizeof(TESObjectSTATData) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESQuestEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | namespace TESQuestEvent 6 | { 7 | enum Type : std::int32_t 8 | { 9 | kUpdateQuestActiveStatus = 0x0, 10 | kUpdateQuestEnableStatus = 0x1, 11 | kUpdateQuestStageChange = 0x2, 12 | kUpdateMiscQuestVisibility = 0x3 13 | }; 14 | 15 | class Event 16 | { 17 | public: 18 | TESQuestEvent::Type changeType; // 00 19 | TESQuest* quest; // 08 20 | }; 21 | static_assert(sizeof(Event) == 0x10); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /include/RE/T/TESTexture1024.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/T/TESTexture.h" 4 | 5 | namespace RE 6 | { 7 | class __declspec(novtable) TESTexture1024 : 8 | public TESTexture // 10 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::TESTexture1024 }; 12 | static constexpr auto VTABLE{ VTABLE::TESTexture1024 }; 13 | 14 | // override (TESTexture) 15 | std::uint32_t GetMaxAllowedSize() override { return 1024; } // 07 16 | }; 17 | static_assert(sizeof(TESTexture1024) == 0x10); 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/T/TESTrackedStatsEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class TESTrackedStatsEvent 8 | { 9 | public: 10 | // members 11 | BSFixedString stat; // 00 12 | std::int32_t value; // 08 13 | }; 14 | static_assert(sizeof(TESTrackedStatsEvent) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TESWeatherList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSSimpleList.h" 4 | 5 | namespace RE 6 | { 7 | class WeatherEntry; 8 | 9 | class TESWeatherList : 10 | public BSSimpleList 11 | { 12 | public: 13 | }; 14 | static_assert(sizeof(TESWeatherList) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/T/TEXTURE_HAVOK_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TEXTURE_HAVOK_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t friction; // 0 10 | std::int8_t restitution; // 1 11 | }; 12 | static_assert(sizeof(TEXTURE_HAVOK_DATA) == 0x2); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/T/TLS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "REX/W32/NT.h" 4 | 5 | namespace RE 6 | { 7 | class TLS 8 | { 9 | public: 10 | [[nodiscard]] static TLS* GetSingleton() 11 | { 12 | return *static_cast(REX::W32::NtCurrentTeb()->threadLocalStoragePointer); 13 | } 14 | 15 | // members 16 | std::byte pad000[0x830]; // 000 17 | bool consoleMode; // 830 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /include/RE/T/TOPIC_INFO_SCENEDATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class TOPIC_INFO_SCENEDATA 6 | { 7 | public: 8 | // members 9 | BGSScene* scene; // 00 10 | std::uint32_t phase; // 08 11 | }; 12 | static_assert(sizeof(TOPIC_INFO_SCENEDATA) == 0x10); 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/T/TravelMarkerStateChange.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSPointerHandle.h" 4 | 5 | namespace RE 6 | { 7 | class MapMarkerData; 8 | 9 | namespace TravelMarkerStateChange 10 | { 11 | class Event 12 | { 13 | public: 14 | ObjectRefHandle markerRef; // 00 15 | MapMarkerData* data; // 08 16 | std::uint32_t selectedMarkerIndex; // 10 17 | bool discovered; // 14 18 | }; 19 | static_assert(sizeof(Event) == 0x18); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/T/TutorialEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSFixedString.h" 4 | 5 | namespace RE 6 | { 7 | class TutorialEvent 8 | { 9 | public: 10 | // members 11 | BSFixedString eventName; // 00 12 | const BGSMessage* assocMsg; // 08 13 | }; 14 | static_assert(sizeof(TutorialEvent) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/U/UIShaderFXInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/U/UIShaderColors.h" 4 | 5 | namespace RE 6 | { 7 | class alignas(0x10) UIShaderFXInfo 8 | { 9 | public: 10 | // members 11 | NiRect renderQuad; // 00 12 | UIShaderColors shaderFX; // 10 13 | }; 14 | static_assert(sizeof(UIShaderFXInfo) == 0x50); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/U/UI_MESSAGE_RESULTS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class UI_MESSAGE_RESULTS : std::int32_t 6 | { 7 | kHandled = 0x0, 8 | kIgnore = 0x1, 9 | kPassOn = 0x2 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/U/UI_MESSAGE_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class UI_MESSAGE_TYPE : std::int32_t 6 | { 7 | kUpdate = 0x0, 8 | kShow = 0x1, 9 | kReshow = 0x2, 10 | kHide = 0x3, 11 | kForceHide = 0x4, 12 | kScaleformEvent = 0x5, 13 | kUserEvent = 0x6, 14 | kInventoryUpdate = 0x7, 15 | kUserProfileChange = 0x8, 16 | kMUStatusChange = 0x9, 17 | kResumeCaching = 0xA, 18 | kUpdateController = 0xB, 19 | kChatterEvent = 0xC, 20 | kTotal = 0xD 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /include/RE/U/UniqueNPCData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class UniqueNPCData 6 | { 7 | public: 8 | // members 9 | TESNPC* npc; // 00 10 | std::uint32_t refID; // 08 11 | BGSLocation* editorLoc; // 10 12 | }; 13 | static_assert(sizeof(UniqueNPCData) == 0x18); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/U/UnloadedRefData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class UnloadedRefData 6 | { 7 | public: 8 | // members 9 | std::uint32_t refID; // 0 10 | std::uint32_t parentSpaceID; // 4 11 | std::uint32_t cellKey; // 8 12 | }; 13 | static_assert(sizeof(UnloadedRefData) == 0xC); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/U/UserEventEnabledEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/U/UserEvents.h" 4 | 5 | namespace RE 6 | { 7 | class UserEventEnabledEvent 8 | { 9 | public: 10 | // members 11 | REX::EnumSet newUserEventFlag; // 0 12 | REX::EnumSet oldUserEventFlag; // 4 13 | REX::EnumSet senderID; // 8 14 | }; 15 | static_assert(sizeof(UserEventEnabledEvent) == 0xC); 16 | } 17 | -------------------------------------------------------------------------------- /include/RE/U/UsesBSGFXFunctionHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/B/BSGFxFunctionBase.h" 4 | #include "RE/B/BSTArray.h" 5 | 6 | namespace RE 7 | { 8 | class UsesBSGFXFunctionHandler 9 | { 10 | public: 11 | static constexpr auto RTTI{ RTTI::UsesBSGFXFunctionHandler }; 12 | 13 | // members 14 | BSTArray> functions; // 00 15 | }; 16 | static_assert(sizeof(UsesBSGFXFunctionHandler) == 0x18); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/V/VATSEvents.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "RE/V/VATS.h" 4 | 5 | namespace RE 6 | { 7 | namespace VATSEvents 8 | { 9 | class ModeChange 10 | { 11 | public: 12 | // members 13 | VATS::VATS_MODE_ENUM oldMode; // 00 14 | VATS::VATS_MODE_ENUM newMode; // 04 15 | }; 16 | static_assert(sizeof(ModeChange) == 0x8); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /include/RE/V/VOICE_TYPE_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class VOICE_TYPE_DATA 6 | { 7 | public: 8 | // members 9 | std::int8_t flags; 10 | }; 11 | static_assert(sizeof(VOICE_TYPE_DATA) == 0x1); 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/W/WEAPONHITBEHAVIOR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class WEAPONHITBEHAVIOR : std::int32_t 6 | { 7 | kNormal = 0x0, 8 | kDismemberOnly = 0x1, 9 | kExplodeOnly = 0x2, 10 | kNoDismemberOrExplode = 0x3 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/RE/W/WEAPON_CULL_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class WEAPON_CULL_TYPE : std::int32_t 6 | { 7 | kGeneral = 0x0, 8 | kAnimation = 0x1, 9 | kWeaponSwitch = 0x2, 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/RE/W/WEAPON_RUMBLE_PATTERN.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class WEAPON_RUMBLE_PATTERN : std::int32_t 6 | { 7 | kConstant = 0x0, 8 | kPeriodicSquare = 0x1, 9 | kPeriodicTriangle = 0x2, 10 | kPeriodicSawtooth = 0x3, 11 | kPatternCount = 0x4 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/RE/W/WEAPON_STATE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class WEAPON_STATE : std::int32_t 6 | { 7 | kSheathed = 0x0, 8 | kWantToDraw = 0x1, 9 | kDrawing = 0x2, 10 | kDrawn = 0x3, 11 | kWantToSheathe = 0x4, 12 | kSheathing = 0x5 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/W/WEAPON_TYPE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | enum class WEAPON_TYPE : std::int32_t 6 | { 7 | kNone = 0xFF, 8 | kHandToHand = 0x0, 9 | kOneHandSword = 0x1, 10 | kOneHandDagger = 0x2, 11 | kOneHandAxe = 0x3, 12 | kOneHandMace = 0x4, 13 | kTwoHandSword = 0x5, 14 | kTwoHandAxe = 0x6, 15 | kBow = 0x7, 16 | kStaff = 0x8, 17 | kGun = 0x9, 18 | kGrenade = 0xA, 19 | kMine = 0xB, 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /include/RE/W/WORLD_MAP_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class WORLD_MAP_DATA 6 | { 7 | public: 8 | // members 9 | std::uint32_t usableWidth; // 00 10 | std::uint32_t usableHeight; // 04 11 | std::int16_t nwCellX; // 08 12 | std::int16_t nwCellY; // 0A 13 | std::int16_t seCellX; // 0C 14 | std::int16_t seCellY; // 0E 15 | }; 16 | static_assert(sizeof(WORLD_MAP_DATA) == 0x10); 17 | } 18 | -------------------------------------------------------------------------------- /include/RE/W/WORLD_MAP_OFFSET_DATA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class WORLD_MAP_OFFSET_DATA 6 | { 7 | public: 8 | // members 9 | float mapScale; // 00 10 | float mapOffsetX; // 04 11 | float mapOffsetY; // 08 12 | float mapOffsetZ; // 0C 13 | }; 14 | static_assert(sizeof(WORLD_MAP_OFFSET_DATA) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/RE/W/WeatherEntry.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class WeatherEntry 6 | { 7 | public: 8 | // members 9 | TESWeather* weather; // 00 10 | std::uint32_t chance; // 08 11 | TESGlobal* chanceVar; // 10 12 | }; 13 | static_assert(sizeof(WeatherEntry) == 0x18); 14 | } 15 | -------------------------------------------------------------------------------- /include/RE/X/XPChangeData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace RE 4 | { 5 | class XPChangeData 6 | { 7 | public: 8 | // members 9 | std::uint32_t playerLevel; // 00 10 | float initialExperiencePoints; // 04 11 | float experiencePointsAdded; // 08 12 | bool syncedXP; // 0C 13 | }; 14 | static_assert(sizeof(XPChangeData) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/A/AllocInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class AllocInfo 6 | { 7 | public: 8 | ~AllocInfo() noexcept {} 9 | 10 | // members 11 | std::uint32_t statID; 12 | }; 13 | static_assert(sizeof(AllocInfo) == 0x4); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/A/Atomic.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | template 6 | class AtomicValueBase 7 | { 8 | public: 9 | // members 10 | volatile T value; // 0 11 | }; 12 | static_assert(sizeof(AtomicValueBase) == 0x04); 13 | 14 | template 15 | class AtomicInt : 16 | public AtomicValueBase // 0 17 | { 18 | public: 19 | }; 20 | static_assert(sizeof(AtomicInt) == 0x04); 21 | } 22 | -------------------------------------------------------------------------------- /include/Scaleform/A/AutoPtr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | template 6 | class AutoPtr 7 | { 8 | public: 9 | // members 10 | T* object; // 00 11 | bool owner; // 08 12 | }; 13 | static_assert(sizeof(AutoPtr) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/F/Flags.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | template > 6 | using Flags = REX::EnumSet; 7 | } 8 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_ASVM.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_AS3_VM.h" 4 | 5 | namespace Scaleform::GFx::AS3 6 | { 7 | class __declspec(novtable) ASVM : 8 | public VM // 00 9 | { 10 | public: 11 | // members 12 | std::byte pad2D0[0x3C8 - 0x2D0]; // 2D0 13 | }; 14 | static_assert(sizeof(ASVM) == 0x3C8); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_ClassTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class ClassTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18 - 0x00]; // 00 13 | }; 14 | static_assert(sizeof(ClassTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_MbiInd.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx::AS3::Abc 4 | { 5 | class MbiInd 6 | { 7 | public: 8 | // members 9 | std::int32_t ind; // 00 10 | }; 11 | static_assert(sizeof(MbiInd) == 0x04); 12 | } 13 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_MetadataTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class MetadataTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18]; // 00 13 | }; 14 | static_assert(sizeof(MetadataTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_MethodBodyTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class MethodBodyTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18]; // 00 13 | }; 14 | static_assert(sizeof(MethodBodyTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_MethodTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class MethodTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18]; // 00 13 | }; 14 | static_assert(sizeof(MethodTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_NamespaceInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_AS3_Abc_NamespaceKind.h" 4 | #include "Scaleform/S/StringDataPtr.h" 5 | 6 | namespace Scaleform::GFx::AS3::Abc 7 | { 8 | class NamespaceInfo 9 | { 10 | public: 11 | // members 12 | NamespaceKind kind; // 00 13 | StringDataPtr NameURI; // 08 14 | }; 15 | static_assert(sizeof(NamespaceInfo) == 0x18); 16 | } 17 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_NamespaceKind.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx::AS3::Abc 4 | { 5 | enum class NamespaceKind : std::int32_t 6 | { 7 | kUndefined = -1, 8 | kPublic, 9 | kProtected, 10 | kStaticProtected, 11 | kPrivate, 12 | kExplicit, 13 | kPackageInternal 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_ScriptTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class ScriptTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18]; // 00 13 | }; 14 | static_assert(sizeof(ScriptTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_Abc_TraitTable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/N/NewOverrideBase.h" 4 | 5 | namespace Scaleform::GFx::AS3::Abc 6 | { 7 | class TraitTable : 8 | public NewOverrideBase<338> 9 | { 10 | public: 11 | // members 12 | std::byte pad[0x18]; // 00 13 | }; 14 | static_assert(sizeof(TraitTable) == 0x18); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_GASRefCountBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_AS3_RefCountBaseGC.h" 4 | 5 | namespace Scaleform::GFx::AS3 6 | { 7 | class __declspec(novtable) GASRefCountBase : 8 | public RefCountBaseGC<328> // 00 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(GASRefCountBase) == 0x28); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_SPtr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx::AS3 4 | { 5 | template 6 | class SPtr 7 | { 8 | public: 9 | // members 10 | T* object; // 00 11 | }; 12 | static_assert(sizeof(SPtr) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_StringManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_ASStringBuiltinManagerT.h" 4 | 5 | namespace Scaleform::GFx::AS3 6 | { 7 | enum class BuiltinType; 8 | 9 | class StringManager : 10 | public ASStringBuiltinManagerT 11 | { 12 | public: 13 | }; 14 | static_assert(sizeof(StringManager) == 0x218); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_VMAbcFile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_AS3_Abc_File.h" 4 | #include "Scaleform/G/GFx_AS3_VMFile.h" 5 | #include "Scaleform/P/Ptr.h" 6 | 7 | namespace Scaleform::GFx::AS3 8 | { 9 | class __declspec(novtable) VMAbcFile : 10 | public VMFile 11 | { 12 | public: 13 | // members 14 | Ptr file; // 98 15 | std::byte padA0[0xE8 - 0xA0]; // A0 16 | }; 17 | static_assert(sizeof(VMAbcFile) == 0xE8); 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_AS3_VMFile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_AS3_GASRefCountBase.h" 4 | 5 | namespace Scaleform::GFx::AS3 6 | { 7 | class VM; 8 | 9 | class __declspec(novtable) VMFile : 10 | public GASRefCountBase 11 | { 12 | public: 13 | // members 14 | VM* vmRef; // 28 15 | std::byte pad30[0x98 - 0x30]; // 30 16 | }; 17 | static_assert(sizeof(VMFile) == 0x98); 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ASConstString.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_ASStringNodeHolder.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class ASConstString : 8 | public ASStringNodeHolder 9 | { 10 | public: 11 | const char* ToCStr() const noexcept 12 | { 13 | return node->data; 14 | } 15 | }; 16 | static_assert(sizeof(ASConstString) == 0x08); 17 | } 18 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ASString.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_ASConstString.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class ASString : 8 | public ASConstString 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(ASString) == 0x08); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ASStringNode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | class ASStringManager; 6 | 7 | class ASStringNode 8 | { 9 | public: 10 | // members 11 | const char* data; // 00 12 | ASStringManager* manager; // 08 13 | union 14 | { 15 | ASStringNode* lower; 16 | ASStringNode* next; 17 | }; // 10 18 | std::uint32_t refCount; // 18 19 | std::uint32_t hashFlags; // 1C 20 | std::uint32_t size; // 20 21 | }; 22 | static_assert(sizeof(ASStringNode) == 0x28); 23 | } 24 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ASStringNodeHolder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_ASStringNode.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class ASStringNodeHolder 8 | { 9 | public: 10 | // members 11 | ASStringNode* node; // 00 12 | }; 13 | static_assert(sizeof(ASStringNodeHolder) == 0x08); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ExternalLibPtr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | class MovieImpl; 6 | 7 | class __declspec(novtable) ExternalLibPtr 8 | { 9 | public: 10 | ExternalLibPtr(MovieImpl* a_movieRoot) : 11 | owner(a_movieRoot) 12 | {} 13 | 14 | virtual ~ExternalLibPtr() = default; 15 | 16 | // members 17 | MovieImpl* owner; 18 | }; 19 | static_assert(sizeof(ExternalLibPtr) == 0x10); 20 | } 21 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_FSCommandHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_State.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class Event; 8 | class Movie; 9 | 10 | class __declspec(novtable) FSCommandHandler : 11 | public State // 00 12 | { 13 | public: 14 | FSCommandHandler() : 15 | State(StateType::kFSCommandHandler) 16 | {} 17 | 18 | virtual void HandleEvent(class Movie* pmovie, const class Event& event) = 0; 19 | }; 20 | static_assert(sizeof(FSCommandHandler) == 0x18); 21 | } 22 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_FocusMovedType.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | enum class FocusMovedType 6 | { 7 | kByMouse = 1, 8 | kByKeyboard, 9 | kByAS 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_HeapId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/S/StatBasicValues.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | enum HeapId : std::int32_t 8 | { 9 | kHeapId_Global = kHeapId_Default, 10 | kHeapId_MovieDef, 11 | kHeapId_MovieView, 12 | kHeapId_MovieData, 13 | kHeapId_Images, 14 | kHeapId_OtherHeaps, 15 | kHeapId_HUDHeaps, 16 | kHeapId_Video, 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_LogBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | template 6 | class __declspec(novtable) LogBase 7 | { 8 | public: 9 | virtual ~LogBase(); // 00 10 | 11 | // add 12 | virtual bool IsVerboseActionErrors(); // 01 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_LogState.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_LogBase.h" 4 | #include "Scaleform/G/GFx_State.h" 5 | #include "Scaleform/L/Log.h" 6 | #include "Scaleform/P/Ptr.h" 7 | 8 | namespace Scaleform::GFx 9 | { 10 | class LogState : 11 | public State, // 00 12 | public LogBase // 18 13 | { 14 | public: 15 | // members 16 | Scaleform::Ptr log; // 20 17 | }; 18 | static_assert(sizeof(LogState) == 0x28); 19 | } 20 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_MemoryContext.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/RefCountBase.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class __declspec(novtable) alignas(0x08) MemoryContext : 8 | public RefCountBase // 00 9 | { 10 | public: 11 | virtual ~MemoryContext() = default; 12 | }; 13 | static_assert(sizeof(MemoryContext) == 0x10); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_PlayState.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | enum class PlayState 6 | { 7 | kPlaying, 8 | kStopped 9 | }; 10 | } 11 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_ResourceId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::GFx 4 | { 5 | class ResourceId 6 | { 7 | public: 8 | ~ResourceId() noexcept {} 9 | 10 | std::uint32_t id; // 00 11 | }; 12 | static_assert(sizeof(ResourceId) == 0x4); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_StatAmp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_StatGroup.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | enum StatAmp 8 | { 9 | kStatAmp_Default = kStatGroup_GFxAmp, 10 | 11 | kStatAmp_Mem, 12 | kStatAmp_ProfileFrame, 13 | kStatAmp_Server, 14 | kStatAmp_Message, 15 | kStatAmp_Callstack, 16 | kStatAmp_InstrBuffer, 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_StatFontCache.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_StatGroup.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | enum StatFontCache 8 | { 9 | kStatFC_Default = kStatGroup_GFxFontCache, 10 | 11 | kStatFC_Mem, 12 | kStatFC_Batch_Mem, 13 | kStatFC_GlyphCache_Mem, 14 | kStatFC_Other_Mem 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_StatIME.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_StatGroup.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | enum StatIME 8 | { 9 | kStatIME_Default = kStatGroup_GFxIME, 10 | 11 | kStatIME_Mem 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_StatMovieData.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_StatGroup.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | enum StatMovieData 8 | { 9 | kStatMD_Default = kStatGroup_GFxMovieData, 10 | 11 | kStatMD_Mem, 12 | kStatMD_CharDefs_Mem, 13 | kStatMD_ShapeData_Mem, 14 | kStatMD_Tags_Mem, 15 | kStatMD_Fonts_Mem, 16 | kStatMD_Images_Mem, 17 | kStatMD_ASBinaryData_Mem, 18 | kStatMD_Other_Mem, 19 | 20 | kStatMD_Time, 21 | kStatMD_Load_Tks, 22 | kStatMD_Bind_Tks 23 | }; 24 | } 25 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_System.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/S/System.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class System : 8 | public Scaleform::System // 0 9 | { 10 | public: 11 | }; 12 | static_assert(std::is_empty_v); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_UserEventHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/G/GFx_State.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class Event; 8 | class Movie; 9 | 10 | class __declspec(novtable) UserEventHandler : 11 | public State // 00 12 | { 13 | public: 14 | UserEventHandler() : 15 | State(StateType::kUserEventHandler) 16 | {} 17 | 18 | virtual void HandleEvent(class Movie* pmovie, const class Event& event) = 0; 19 | }; 20 | static_assert(sizeof(UserEventHandler) == 0x18); 21 | } 22 | -------------------------------------------------------------------------------- /include/Scaleform/G/GFx_Viewport.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_Viewport.h" 4 | 5 | namespace Scaleform::GFx 6 | { 7 | class Viewport : 8 | public Render::Viewport 9 | { 10 | public: 11 | // members 12 | float scale; // 2C 13 | float aspectRatio; // 30 14 | }; 15 | static_assert(sizeof(Viewport) == 0x34); 16 | } 17 | -------------------------------------------------------------------------------- /include/Scaleform/L/Lock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class Lock 6 | { 7 | public: 8 | // members 9 | REX::W32::CRITICAL_SECTION cs; // 00 10 | }; 11 | static_assert(sizeof(Lock) == 0x28); 12 | } 13 | -------------------------------------------------------------------------------- /include/Scaleform/L/LogMessageId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class LogMessageId 6 | { 7 | public: 8 | LogMessageId(std::int32_t a_id) : 9 | id(a_id) 10 | {} 11 | 12 | ~LogMessageId() noexcept {} 13 | 14 | // members 15 | std::int32_t id; // 0 16 | }; 17 | static_assert(sizeof(LogMessageId) == 0x4); 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/M/Mutex.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/A/AcquireInterface.h" 4 | #include "Scaleform/W/Waitable.h" 5 | 6 | namespace Scaleform 7 | { 8 | class MutexImpl; 9 | 10 | class __declspec(novtable) Mutex : 11 | public Waitable, // 00 12 | public AcquireInterface // 18 13 | { 14 | public: 15 | // members 16 | MutexImpl* impl; // 20 17 | }; 18 | static_assert(sizeof(Mutex) == 0x28); 19 | } 20 | -------------------------------------------------------------------------------- /include/Scaleform/N/NewOverrideBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/M/Memory.h" 4 | 5 | namespace Scaleform 6 | { 7 | template 8 | class NewOverrideBase 9 | { 10 | public: 11 | SF_HEAP_REDEFINE_NEW(NewOverrideBase) 12 | }; 13 | static_assert(std::is_empty_v>); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_ContextData_ImplMixin.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | class LinearHeap; 6 | 7 | namespace ContextImpl 8 | { 9 | class EntryData; 10 | 11 | template 12 | class ContextData_ImplMixin : public B 13 | { 14 | public: 15 | virtual EntryData* ConstructCopy(LinearHeap& heap) const; 16 | virtual void CopyTo(void* pdest) const; 17 | virtual void Destroy(); 18 | }; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_ContextLock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/L/Lock.h" 4 | #include "Scaleform/R/RefCountBase.h" 5 | 6 | namespace Scaleform::Render::ContextImpl 7 | { 8 | class Context; 9 | 10 | class __declspec(novtable) ContextLock : 11 | public RefCountBase // 00 12 | { 13 | public: 14 | // members 15 | Lock lockObject; // 10 16 | Context* context; // 38 17 | }; 18 | static_assert(sizeof(ContextLock) == 0x40); 19 | } 20 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_DisplayHandle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_ContextImpl_RTHandle.h" 4 | 5 | namespace Scaleform::Render::ContextImpl 6 | { 7 | template 8 | class DisplayHandle : 9 | public RTHandle // 0 10 | { 11 | public: 12 | }; 13 | //static_assert(sizeof(DisplayHandle) == 0x8); 14 | } 15 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_EntryChange.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render::ContextImpl 4 | { 5 | class Entry; 6 | 7 | class EntryChange 8 | { 9 | public: 10 | // members 11 | Entry* node; // 00 12 | union 13 | { 14 | std::uint32_t changeBits; 15 | EntryChange* nextFreeNode; 16 | }; // 08 17 | }; 18 | static_assert(sizeof(EntryChange) == 0x10); 19 | } 20 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_EntryListAccessor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render::ContextImpl 4 | { 5 | class EntryListAccessor 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ContextImpl_EntryPage.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_ContextImpl_Entry.h" 4 | #include "Scaleform/R/Render_ContextImpl_EntryPageBase.h" 5 | 6 | namespace Scaleform::Render::ContextImpl 7 | { 8 | class EntryPage : 9 | public EntryPageBase // 000 10 | { 11 | public: 12 | // members 13 | Entry entries[72]; // 038 14 | }; 15 | static_assert(sizeof(EntryPage) == 0xFF8); 16 | } 17 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_EdgeAAMode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | enum class EdgeAAMode : std::int32_t 6 | { 7 | kInherit = 0x0000, 8 | kOn = 1 << 2, 9 | kOff = 1 << 3, 10 | kDisable = kOn | kOff 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_Interfaces.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/T/ThreadId.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class HAL; 8 | class Renderer2D; 9 | class TextureManager; 10 | 11 | class Interfaces 12 | { 13 | public: 14 | // members 15 | TextureManager* textureManager; // 00 16 | HAL* hal; // 08 17 | Renderer2D* renderer2D; // 10 18 | ThreadId renderThreadID; // 18 19 | }; 20 | static_assert(sizeof(Interfaces) == 0x20); 21 | } 22 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_PagedItemBuffer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | template 6 | class PagedItemBuffer 7 | { 8 | public: 9 | class Page 10 | { 11 | public: 12 | // members 13 | Page* next; // 00 14 | std::int32_t count; // 08 15 | C items[N]; // ?? 16 | }; 17 | 18 | // members 19 | Page* pages; // 00 20 | Page* last; // 08 21 | }; 22 | static_assert(sizeof(PagedItemBuffer) == 0x10); 23 | } 24 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_Point.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | template 6 | class Point 7 | { 8 | public: 9 | // members 10 | T x; // 00 11 | T y; // ?? 12 | }; 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_Rect.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | template 6 | class RectData 7 | { 8 | public: 9 | // members 10 | T x1; // 00 11 | T y1; // ?? 12 | T x2; // ?? 13 | T y2; // ?? 14 | }; 15 | 16 | template 17 | class Rect : 18 | public RectData // 00 19 | { 20 | public: 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ThreadCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/RefCountBase.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class __declspec(novtable) ThreadCommand : 8 | public RefCountBase // 00 9 | { 10 | public: 11 | // add 12 | virtual void Execute() = 0; // 01 13 | }; 14 | static_assert(sizeof(ThreadCommand) == 0x10); 15 | } 16 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_ThreadCommandQueue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform::Render 4 | { 5 | class Interfaces; 6 | class ThreadCommand; 7 | 8 | class __declspec(novtable) ThreadCommandQueue 9 | { 10 | public: 11 | virtual ~ThreadCommandQueue() = default; // 00 12 | 13 | // add 14 | virtual void PushThreadCommand(ThreadCommand* a_command) = 0; // 01 15 | virtual void GetRenderInterfaces(Interfaces* a_ptr); // 02 16 | }; 17 | static_assert(sizeof(ThreadCommandQueue) == 0x8); 18 | } 19 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_TreeContainer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_TreeNode.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class TreeContainer : 8 | public TreeNode // 00 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(TreeContainer) == 0x38); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_TreeNode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_ContextImpl_Entry.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class TreeNode : 8 | public ContextImpl::Entry // 00 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(TreeNode) == 0x38); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_TreeRoot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_TreeContainer.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class TreeRoot : 8 | public TreeContainer 9 | { 10 | public: 11 | }; 12 | static_assert(sizeof(TreeRoot) == 0x38); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/R/Render_TreeShape.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Scaleform/R/Render_TreeNode.h" 4 | 5 | namespace Scaleform::Render 6 | { 7 | class TreeShape : 8 | public TreeNode 9 | { 10 | public: 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /include/Scaleform/S/StatBag.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class StatBag 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/Scaleform/S/StatBasicValues.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | enum StatBasicValues : std::int32_t 6 | { 7 | kStatGroup_Default = 0, 8 | kStatGroup_Core = 16, 9 | 10 | kStat_Mem = kStatGroup_Default + 1, 11 | kStat_Default_Mem = kStat_Mem + 1, 12 | 13 | kStatHeap_Start = kStatGroup_Core, 14 | 15 | kStat_MaxId = 64 << 6, 16 | kStat_EntryCount = 512, 17 | 18 | kHeapId_Default = 1 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /include/Scaleform/S/StringDataPtr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class StringDataPtr 6 | { 7 | public: 8 | // members 9 | const char* str; // 00 10 | std::uint64_t size; // 08 11 | }; 12 | static_assert(sizeof(StringDataPtr) == 0x10); 13 | } 14 | -------------------------------------------------------------------------------- /include/Scaleform/S/System.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class System 6 | { 7 | public: 8 | }; 9 | static_assert(std::is_empty_v); 10 | } 11 | -------------------------------------------------------------------------------- /include/Scaleform/T/ThreadId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | using ThreadId = void*; 6 | 7 | inline ThreadId GetCurrentThreadId() 8 | { 9 | return reinterpret_cast( 10 | static_cast(REX::W32::GetCurrentThreadId())); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /include/Scaleform/W/WaitCondition.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace Scaleform 4 | { 5 | class WaitConditionImpl; 6 | 7 | class WaitCondition 8 | { 9 | public: 10 | ~WaitCondition() noexcept {} 11 | 12 | // members 13 | WaitConditionImpl* impl; // 00 14 | }; 15 | static_assert(sizeof(WaitCondition) == 0x8); 16 | } 17 | -------------------------------------------------------------------------------- /src/F4SE/Impl/PCH.cpp: -------------------------------------------------------------------------------- 1 | #include "F4SE/Impl/PCH.h" 2 | -------------------------------------------------------------------------------- /src/RE/A/Actor.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/A/Actor.h" 2 | 3 | #include "RE/T/TESBoundObject.h" 4 | #include "RE/T/TESNPC.h" 5 | 6 | namespace RE 7 | { 8 | TESNPC* Actor::GetNPC() const noexcept 9 | { 10 | const auto objRef = GetObjectReference(); 11 | assert(objRef->GetFormType() == ENUM_FORM_ID::kNPC_); 12 | return static_cast(objRef); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/RE/B/BGSInventoryItem.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BGSInventoryItem.h" 2 | 3 | namespace RE 4 | { 5 | std::uint32_t BGSInventoryItem::GetCount() const noexcept 6 | { 7 | std::uint32_t count = 0; 8 | for (auto iter = stackData.get(); iter; iter = iter->nextStack.get()) { 9 | count += iter->GetCount(); 10 | } 11 | return count; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/RE/B/BGSKeyword.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BGSKeyword.h" 2 | 3 | namespace RE 4 | { 5 | namespace detail 6 | { 7 | BGSKeyword* BGSKeywordGetTypedKeywordByIndex(KeywordType a_type, std::uint16_t a_index) 8 | { 9 | return BGSKeyword::GetTypedKeywordByIndex(a_type, a_index); 10 | } 11 | 12 | std::uint16_t BGSKeywordGetIndexForTypedKeyword(BGSKeyword* a_keyword, KeywordType a_type) 13 | { 14 | return BGSKeyword::GetIndexForTypedKeyword(a_keyword, a_type); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/RE/B/BSCRC32.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSCRC32.h" 2 | 3 | namespace RE 4 | { 5 | template struct BSCRC32; 6 | template struct BSCRC32; 7 | template struct BSCRC32; 8 | template struct BSCRC32; 9 | template struct BSCRC32; 10 | template struct BSCRC32; 11 | template struct BSCRC32; 12 | template struct BSCRC32; 13 | } 14 | -------------------------------------------------------------------------------- /src/RE/B/BSResource.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSResource.h" 2 | 3 | namespace RE::BSResource 4 | { 5 | ErrorCode GetOrCreateStream(const char* a_fileName, BSTSmartPointer& a_result, bool a_writable, Location* a_optionalStart) 6 | { 7 | using func_t = decltype(&GetOrCreateStream); 8 | static REL::Relocation func{ ID::BSResource::GetOrCreateStream }; 9 | return func(a_fileName, a_result, a_writable, a_optionalStart); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/RE/B/BSScript_Internal_VirtualMachine.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSScript_Internal_VirtualMachine.h" 2 | 3 | #include "RE/G/GameScript.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSScript 8 | { 9 | namespace Internal 10 | { 11 | VirtualMachine* VirtualMachine::GetSingleton() 12 | { 13 | auto vm = GameVM::GetSingleton(); 14 | return vm ? static_cast(vm->impl.get()) : nullptr; 15 | } 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/RE/B/BSScript_StackFrame.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSScript_StackFrame.h" 2 | 3 | #include "RE/B/BSScript_Internal_Stack.h" 4 | 5 | namespace RE 6 | { 7 | namespace BSScript 8 | { 9 | std::uint32_t StackFrame::GetPageForFrame() const 10 | { 11 | return parent->GetPageForFrame(this); 12 | } 13 | 14 | Variable& StackFrame::GetStackFrameVariable(std::uint32_t a_index, std::uint32_t a_pageHint) const 15 | { 16 | return parent->GetStackFrameVariable(this, a_index, a_pageHint); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/RE/B/BSScript_Struct.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSScript_Struct.h" 2 | 3 | namespace RE::BSScript 4 | { 5 | Struct::~Struct() 6 | { 7 | if (constructed) { 8 | const std::uint32_t size = type ? type->variables.size() : 0; 9 | for (std::uint32_t i = 0; i < size; ++i) { 10 | variables[i].reset(); 11 | } 12 | 13 | constructed = false; 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/RE/B/BSScript_StructTypeInfo.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSScript_StructTypeInfo.h" 2 | 3 | namespace RE 4 | { 5 | namespace BSScript 6 | { 7 | TypeInfo::RawType StructTypeInfo::GetRawType() const 8 | { 9 | return TypeInfo::RawType::kStruct; 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/RE/B/BSSpring_SpringState.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSSpring_SpringState.h" 2 | 3 | namespace RE 4 | { 5 | namespace BSSpring 6 | { 7 | template class SpringState; 8 | static_assert(sizeof(SpringState) == 0xC); 9 | 10 | template class SpringState; 11 | static_assert(sizeof(SpringState) == 0x14); 12 | 13 | template class SpringState; 14 | static_assert(sizeof(SpringState) == 0x1C); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/RE/B/BSTArray.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSTArray.h" 2 | 3 | namespace RE 4 | { 5 | template class BSTAlignedHeapArrayAllocator<0x10>::Allocator; 6 | static_assert(sizeof(BSTAlignedHeapArrayAllocator<0x10>::Allocator) == 0x10); 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/B/BSTDataBuffer.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSTDataBuffer.h" 2 | 3 | namespace RE 4 | { 5 | template class BSTDataBuffer<1>; 6 | static_assert(sizeof(BSTDataBuffer<1>) == 0x10); 7 | 8 | template class BSTDataBuffer<2>; 9 | static_assert(sizeof(BSTDataBuffer<2>) == 0x10); 10 | } 11 | -------------------------------------------------------------------------------- /src/RE/B/BSTInterpolator.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/BSTInterpolator.h" 2 | 3 | namespace RE 4 | { 5 | template class BSTInterpolator; 6 | static_assert(sizeof(BSTInterpolator) == 0x18); 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/B/ButtonEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/B/ButtonEvent.h" 2 | 3 | namespace RE 4 | { 5 | template ButtonEvent* InputEvent::As() noexcept; 6 | template const ButtonEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/C/Calendar.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/C/Calendar.h" 2 | 3 | namespace RE 4 | { 5 | float Calendar::GetHoursPassed() const noexcept 6 | { 7 | const auto days = gameDaysPassed ? gameDaysPassed->GetValue() : 1.0F; 8 | return days * 24.0F; 9 | } 10 | 11 | std::uint32_t Calendar::GetMonth() const noexcept 12 | { 13 | return gameMonth ? static_cast(gameMonth->value) : 8; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/RE/C/CharacterEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/C/CharacterEvent.h" 2 | 3 | namespace RE 4 | { 5 | template CharacterEvent* InputEvent::As() noexcept; 6 | template const CharacterEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/C/CursorMoveEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/C/CursorMoveEvent.h" 2 | 3 | namespace RE 4 | { 5 | template CursorMoveEvent* InputEvent::As() noexcept; 6 | template const CursorMoveEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/D/DeviceConnectEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/D/DeviceConnectEvent.h" 2 | 3 | namespace RE 4 | { 5 | template DeviceConnectEvent* InputEvent::As() noexcept; 6 | template const DeviceConnectEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/E/ExtraInstanceData.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/E/ExtraInstanceData.h" 2 | 3 | #include "RE/T/TBO_InstanceData.h" 4 | 5 | namespace RE 6 | { 7 | ExtraInstanceData::ExtraInstanceData() : 8 | ExtraInstanceData(nullptr, nullptr) 9 | {} 10 | 11 | ExtraInstanceData::ExtraInstanceData(const TESBoundObject* a_base, BSTSmartPointer a_data) : 12 | BSExtraData(TYPE), 13 | base(a_base), 14 | data(std::move(a_data)) 15 | { 16 | REX::EMPLACE_VTABLE(this); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/RE/Fallout.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/Fallout.h" 2 | -------------------------------------------------------------------------------- /src/RE/G/GetCurrentPositionFunctor.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/G/GetCurrentPositionFunctor.h" 2 | 3 | namespace RE 4 | { 5 | template class GetCurrentPositionFunctor; 6 | static_assert(std::is_empty_v>); 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/I/IDEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/I/IDEvent.h" 2 | 3 | namespace RE 4 | { 5 | template IDEvent* InputEvent::As(); 6 | template const IDEvent* InputEvent::As() const; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/I/InventoryInterface.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/I/InventoryInterface.h" 2 | 3 | namespace RE 4 | { 5 | std::uint32_t BSCRC32::operator()(InventoryInterface::Handle a_data) const noexcept 6 | { 7 | return BSCRC32()(a_data.id); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/RE/K/KinectEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/K/KinectEvent.h" 2 | 3 | namespace RE 4 | { 5 | template KinectEvent* InputEvent::As() noexcept; 6 | template const KinectEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/M/MouseMoveEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/M/MouseMoveEvent.h" 2 | 3 | namespace RE 4 | { 5 | template MouseMoveEvent* InputEvent::As() noexcept; 6 | template const MouseMoveEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/N/NiObjectNET.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/N/NiObjectNET.h" 2 | 3 | namespace RE 4 | { 5 | NiObjectNET::NiObjectNET() { REX::EMPLACE_VTABLE(this); } 6 | 7 | NiObjectNET::~NiObjectNET() {} 8 | 9 | NiExtraData* NiObjectNET::GetExtraData(BSFixedString a_key) const noexcept 10 | { 11 | if (extra) { 12 | for (auto it = extra->begin(); it != extra->end(); ++it) { 13 | if ((*it)->name == a_key) { 14 | return *it; 15 | } 16 | } 17 | } 18 | 19 | return nullptr; 20 | } 21 | // NOLINT(modernize-use-equals-default) 22 | } 23 | -------------------------------------------------------------------------------- /src/RE/N/NiRect.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/N/NiRect.h" 2 | 3 | namespace RE 4 | { 5 | template class NiRect; 6 | static_assert(sizeof(NiRect) == 0x10); 7 | 8 | template class NiRect; 9 | static_assert(sizeof(NiRect) == 0x10); 10 | 11 | template class NiRect; 12 | static_assert(sizeof(NiRect) == 0x10); 13 | } 14 | -------------------------------------------------------------------------------- /src/RE/T/TESValueForm.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/T/TESValueForm.h" 2 | 3 | #include "RE/C/CHANGE_TYPES.h" 4 | #include "RE/T/TESForm.h" 5 | 6 | namespace RE 7 | { 8 | void TESValueForm::SetFormValue(TESForm& a_form, std::int32_t a_value) 9 | { 10 | if (const auto val = a_form.As()) { 11 | val->value = a_value; 12 | a_form.AddChange(CHANGE_TYPES::kBaseObjectValue); 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/RE/T/ThumbstickEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/T/ThumbstickEvent.h" 2 | 3 | namespace RE 4 | { 5 | template ThumbstickEvent* InputEvent::As() noexcept; 6 | template const ThumbstickEvent* InputEvent::As() const noexcept; 7 | } 8 | -------------------------------------------------------------------------------- /src/RE/W/WorkbenchMenuBase.cpp: -------------------------------------------------------------------------------- 1 | #include "RE/W/WorkbenchMenuBase.h" 2 | 3 | #include "RE/P/PlayerCharacter.h" 4 | 5 | namespace RE 6 | { 7 | WorkbenchMenuBase::InitParams::InitParams() 8 | { 9 | workbenchFurniture.reset(); 10 | inventorySource = RE::PlayerCharacter::GetPlayerHandle(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/Scaleform/Scaleform.cpp: -------------------------------------------------------------------------------- 1 | #include "Scaleform/Scaleform.h" 2 | --------------------------------------------------------------------------------