O

`OverworldGenerator::_makeLayers::$2867EA52F754A99BBF15CBCDF29DF3E2`

Offset	Type	Name
0	(8) `const BiomeRegistry *`	biomeRegistry

`OwnedActorSet`

Offset	Type	Name
0	(24) `std::vector<std::unique_ptr<Actor>>`	c

`OwnerStorageEntity::EntityContextOwned`

Offset	Type	Name
0	(16) `EntityContext`	baseclass_0

`OpenDoorAnnotationComponent`

Offset	Type	Name
0	(80) `std::queue<BlockPos>`	mPassedDoorPositions

`OptionalString`

Offset	Type	Name
0	(1) `bool`	valid
8	(32) `std::string`	string

`Option::StringFilter`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<std::string (const std::string &)>::_Invoker_type`	_M_invoker

`Option::BoolFilter`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<bool (bool)>::_Invoker_type`	_M_invoker

`Option::SaveIntCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<int (int)>::_Invoker_type`	_M_invoker

`OnScreenTextureAnimationPacket`

Offset	Type	Name
0	(36) `Packet:288`	baseclass_0
36	(4) `unsigned int`	mEffectID

`OwnerPtr<EntityId>`

Offset	Type	Name
0	(24) `EntityRefTraits::OwnerStorage`	baseclass_0

`OverworldHeightAttributes`

Offset	Type	Name
0	(8) `BiomeHeight`	mHeightParams

`OceanMixerLayer::OceanData`

Offset	Type	Name
0	(8) `std::unique_ptr<char []>`	mResult

`optional_ref<int>`

Offset	Type	Name
0	(8) `int *`	ptr

`OverworldDimension`

Offset	Type	Name
0	(1216) `Dimension`	baseclass_0

`OceanRuinConfiguration`

Offset	Type	Name
0	(4) `OceanTempCategory`	type
4	(4) `float`	largeProbability
8	(4) `float`	clusterProbability

`OwnerPtr<PerlinSimplexNoise>`

Offset	Type	Name
0	(16) `SharePtrRefTraits<PerlinSimplexNoise>::OwnerStorage`	baseclass_0

`optional_ref<const Localization>`

Offset	Type	Name
0	(8) `const Localization *`	ptr

`Ocelot::updateEntitySpecificMolangVariables::$7EF7C94BEAB75C6CEF4ADFB99B570420`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

`OwnerPtrT<FeatureRefTraits>`

Offset	Type	Name
0	(24) `FeatureRefTraits::OwnerStorage`	baseclass_0

`ObjectiveCriteria`

Offset	Type	Name
0	(32) `const std::string`	mName
32	(1) `const bool`	mReadOnly
33	(1) `const ObjectiveRenderType_0`	mRenderType

`OpenDoorAnnotationSystem`

struct __cppobj OpenDoorAnnotationSystem : ITickingSystem
{
};

`OwnerStorageSharePtr<EntityRegistryOwned>`

struct OwnerStorageSharePtr<EntityRegistryOwned>
{
  std::shared_ptr<EntityRegistryOwned> mValue;
};

`OwnerPtrT<EntityRegistryRefTraits>`

struct __cppobj OwnerPtrT<EntityRegistryRefTraits> : EntityRegistryRefTraits::OwnerStorage
{
};

`OwnerPtrT<EntityRegistryRefTraits>::OwnerStackRef`

typedef EntityRegistryRefTraits::OwnerStackRef OwnerPtrT<EntityRegistryRefTraits>::OwnerStackRef;

`OwnerStorageEntity`

struct OwnerStorageEntity
{
  std::optional<OwnerStorageEntity::EntityContextOwned> mContext;
};

`OwnerPtrT<EntityRefTraits>`

struct __cppobj OwnerPtrT<EntityRefTraits> : EntityRefTraits::OwnerStorage
{
};

`OwnerPtrT<EntityRefTraits>::OwnerStackRef`

typedef EntityRefTraits::OwnerStackRef OwnerPtrT<EntityRefTraits>::OwnerStackRef;

`OwnerStorageFeature`

struct OwnerStorageFeature
{
  std::optional<std::reference_wrapper<FeatureRegistry> > mRegistry;
  size_t mIndex;
};

`OreFeature`

struct __cppobj OreFeature : IFeature
{
  int mCount;
  float mCountf;
  float mCountfInv;
  const Block *mBlock;
  std::vector<const Block *> mMayReplace;
};

`OakFeature`

struct __cppobj __attribute__((aligned(8))) OakFeature : TreeFeature
{
};

`OwnerPtrT<FeatureRefTraits>::OwnerStackRef`

typedef FeatureRefTraits::OwnerStackRef OwnerPtrT<FeatureRefTraits>::OwnerStackRef;

`OverworldGenerator`

struct __cppobj OverworldGenerator : ChunkSource, WorldGenerator
{
  const bool legacyDevice;
  BeardKernel mBeardKernel;
  PerlinNoisePtr minLimitPerlinNoise;
  PerlinNoisePtr maxLimitPerlinNoise;
  PerlinNoisePtr mainPerlinNoise;
  Unique<PerlinSimplexNoise> surfaceNoise;
  PerlinNoisePtr scaleNoise;
  PerlinNoisePtr depthNoise;
  PerlinNoisePtr forestNoise;
  float biomeWeights[25];
  ThreadLocal<OverworldGenerator::ThreadData> generatorHelpersPool;
  VillageFeature villageFeature;
  StrongholdFeature strongholdFeature;
  RandomScatteredLargeFeature scatteredFeature;
  MineshaftFeature mineshaftFeature;
  MonsterRoomFeature monsterRoomFeature;
  OceanMonumentFeature oceanMonumentFeature;
  OceanRuinFeature oceanRuinFeature;
  WoodlandMansionFeature woodlandMansionFeature;
  ShipwreckFeature shipwreckFeature;
  BuriedTreasureFeature buriedChestFeature;
  LargeCaveFeature caveFeature;
  CanyonFeature canyonFeature;
  UnderwaterLargeCaveFeature underwaterCaveFeature;
  UnderwaterCanyonFeature underwaterCanyonFeature;
  PillagerOutpostFeature pillagerOutpostFeature;
  ConstLayerPtr<Biome *> mBlockResolutionLayer;
  ConstLayerPtr<Biome *> m4x4ResolutionLayer;
  std::shared_ptr<BiomeSourceGetBiomeCache> mBiomeSourceCache;
};

`OverworldGenerator::ThreadData`

struct __attribute__((aligned(8))) OverworldGenerator::ThreadData
{
  float buffer[1024];
  float depthBuffer[256];
  float dataBuffer[256];
  std::array<long,32768> blockBuffer;
  float *fi;
  float *fis;
  Random random;
};

`OceanMixerLayer`

struct __cppobj OceanMixerLayer : MixerLayer<Biome *,Biome *,BiomeTemperatureCategory>
{
  Biome *mGenericShallowOcean;
  Biome *mGenericDeepOcean;
  std::vector<std::pair<Biome *,unsigned int>> mShallowOceanBiomes[5];
  std::vector<std::pair<Biome *,unsigned int>> mDeepOceanBiomes[5];
};

`OceanMonumentFeature`

struct __cppobj OceanMonumentFeature : StructureFeature:1760
{
  int mMonumentSpacing;
  int mMinMonumentSeparation;
  std::vector<int> allowedBiomes;
  std::vector<int> allowedSpawnBiomes;
};

`OceanRuinFeature`

struct __cppobj OceanRuinFeature : StructureFeature:1760
{
  int mRuinSpacing;
  int mMinRuinSeparation;
  std::vector<int> allowedBiomes;
  OverworldGenerator *mLevelSource;
  OceanMonumentFeature *mMonument;
};

`OceanRuinStart`

struct __cppobj __attribute__((aligned(8))) OceanRuinStart : StructureStart
{
  OceanRuinConfiguration mConfig;
};

`OceanRuinPieces::OceanRuinPiece`

struct __cppobj OceanRuinPieces::OceanRuinPiece : TemplateStructurePiece
{
  StructureManager *mStructureManager;
  std::string mTemplateName;
  OceanTempCategory mBiomeType;
  float mIntegrity;
  bool mIsLarge;
  Rotation_0 mRotation;
  BlockPos mPosition;
};

`OceanRuinPieces`

struct OceanRuinPieces
{
  __int8 gap0[1];
};

`Option`

struct Option
{
  int (**_vptr$Option)(void);
  std::unique_ptr<OptionLock> mLock;
  std::vector<OptionObserver> mObservers;
  std::string mSaveTag;
  std::string mTelemetryProperty;
  const OptionID mID;
  const OptionOwnerType mOwnerType;
  OptionType mOptionType;
  const std::string mCaptionId;
  const OptionResetFlags mOptionResetFlags;
  Option *mOverrideSource;
  std::function<void (bool)> mRequestSaveCallback;
};

`OnFriendlyAngerDescription`

struct __cppobj OnFriendlyAngerDescription : TriggerDescription
{
};

`OnHitSubcomponent`

struct OnHitSubcomponent
{
  int (**_vptr$OnHitSubcomponent)(void);
};

`OwnerPtr<EntityRegistry>`

typedef OwnerPtrT<EntityRegistryRefTraits> OwnerPtr<EntityRegistry>;

`Objective`

struct Objective
{
  std::unordered_map<ScoreboardId,int> mScores;
  const std::string mName;
  std::string mDisplayName;
  const ObjectiveCriteria *mCriteria;
};

`OptionObserver`

struct OptionObserver
{
  void *mToken;
  ValueChangedCallback mOnValueChangeCallback;
  InputModeValueChangedCallback mOnInputModeValueChangeCallback;
};

`OptionLock`

struct OptionLock
{
  std::function<bool ()> isModifiableCondition;
  void *mToken;
};

`OwnedActorList`

typedef std::vector<std::unique_ptr<Actor>> OwnedActorList;

`OnDeathDescription`

struct __cppobj OnDeathDescription : TriggerDescription
{
};

`OnHurtByPlayerDescription`

struct __cppobj OnHurtByPlayerDescription : TriggerDescription
{
};

`OnHurtDescription`

struct __cppobj OnHurtDescription : TriggerDescription
{
};

`OnIgniteDescription`

struct __cppobj OnIgniteDescription : TriggerDescription
{
};

`OnStartLandingDescription`

struct __cppobj OnStartLandingDescription : TriggerDescription
{
};

`OnStartTakeoffDescription`

struct __cppobj OnStartTakeoffDescription : TriggerDescription
{
};

`OnTargetAcquiredDescription`

struct __cppobj OnTargetAcquiredDescription : TriggerDescription
{
};

`OnTargetEscapeDescription`

struct __cppobj OnTargetEscapeDescription : TriggerDescription
{
};

`OnWakeWithOwnerDescription`

struct __cppobj OnWakeWithOwnerDescription : TriggerDescription
{
};

`OpenDoorAnnotationDescription`

struct __cppobj OpenDoorAnnotationDescription : ComponentDescription
{
};

`OverloadSyntaxInformation`

struct OverloadSyntaxInformation
{
  std::string text;
  OverloadSyntaxInformation::CursorPos start;
  OverloadSyntaxInformation::CursorPos length;
};

`Ocelot`

struct __cppobj Ocelot : Animal
{
};

`OwnerHurtByTargetGoal`

struct __cppobj OwnerHurtByTargetGoal : TargetGoal
{
  TempEPtr<Mob> mOwnerHurtBy;
  Mob *mMob;
};

`OwnerHurtTargetGoal`

struct __cppobj __attribute__((aligned(8))) OwnerHurtTargetGoal : TargetGoal
{
  TempEPtr<Mob> mLastOwnerHurt;
  Mob *mMob;
  int mTimestamp;
};

`OcelotAttackGoal`

struct __cppobj __attribute__((aligned(8))) OcelotAttackGoal : Goal:96
{
  int mAttackTime;
  Mob *mMob;
  float mWalkSpeedModifier;
  float mSprintSpeedModifier;
  float mSneakSpeedModifier;
};

`OcelotSitOnBlockGoal`

struct __cppobj OcelotSitOnBlockGoal : BaseMoveToBlockGoal
{
  Mob *mMob;
};

`OfferFlowerGoal`

struct __cppobj OfferFlowerGoal : Goal
{
  TempEPtr<Mob> mOfferedToMob;
  int mGameTicks;
  IronGolem *mGolem;
};

`OpenDoorGoal`

struct __cppobj OpenDoorGoal : DoorInteractGoal
{
  bool mCloseDoor;
  int mForgetTime;
  Mob *mMob;
};

`OwnerPtrT<SharePtrRefTraits<PerlinSimplexNoise> >`

struct __cppobj OwnerPtrT<SharePtrRefTraits<PerlinSimplexNoise> > : SharePtrRefTraits<PerlinSimplexNoise>::OwnerStorage
{
};

`OwnerStorageSharePtr<PerlinSimplexNoise>`

struct OwnerStorageSharePtr<PerlinSimplexNoise>
{
  std::shared_ptr<PerlinSimplexNoise> mValue;
};

`OwnerPtrT<SharePtrRefTraits<PerlinSimplexNoise> >::OwnerStackRef`

typedef SharePtrRefTraits<PerlinSimplexNoise>::OwnerStackRef OwnerPtrT<SharePtrRefTraits<PerlinSimplexNoise> >::OwnerStackRef;

`OreBlock`

struct __cppobj OreBlock : BlockLegacy
{
};

`OldLogBlock`

struct __cppobj OldLogBlock : LogBlock
{
};

`OldLeafBlock`

struct __cppobj OldLeafBlock : LeafBlock
{
};

`ObsidianBlock`

struct __cppobj __attribute__((aligned(8))) ObsidianBlock : BlockLegacy
{
  bool mIsGlowing;
};

`ObserverBlock`

struct __cppobj ObserverBlock : FaceDirectionalBlock
{
};

`OceanMonumentStart`

struct __cppobj __attribute__((aligned(8))) OceanMonumentStart : StructureStart
{
  bool isCreated;
};

`OceanMonumentPiece`

struct __cppobj OceanMonumentPiece : StructurePiece
{
  bool mDoFill;
  Shared<RoomDefinition> mRoomDefinition;
};

`OceanMonumentEntryRoom`

struct __cppobj OceanMonumentEntryRoom : OceanMonumentPiece
{
};

`OceanMonumentCoreRoom`

struct __cppobj OceanMonumentCoreRoom : OceanMonumentPiece
{
};

`OceanMonumentWingRoom`

struct __cppobj __attribute__((aligned(4))) OceanMonumentWingRoom : OceanMonumentPiece
{
  int mMainDesign;
  bool mIsRightWing;
};

`OceanMonumentPenthouse`

struct __cppobj OceanMonumentPenthouse : OceanMonumentPiece
{
};

`OceanMonumentSimpleRoom`

struct __cppobj __attribute__((aligned(8))) OceanMonumentSimpleRoom : OceanMonumentPiece
{
  int mMainDesign;
};

`OceanMonumentSimpleTopRoom`

struct __cppobj OceanMonumentSimpleTopRoom : OceanMonumentPiece
{
};

`OceanMonumentDoubleYRoom`

struct __cppobj OceanMonumentDoubleYRoom : OceanMonumentPiece
{
};

`OceanMonumentDoubleXRoom`

struct __cppobj OceanMonumentDoubleXRoom : OceanMonumentPiece
{
};

`OceanMonumentDoubleZRoom`

struct __cppobj OceanMonumentDoubleZRoom : OceanMonumentPiece
{
};

`OceanMonumentDoubleXYRoom`

struct __cppobj OceanMonumentDoubleXYRoom : OceanMonumentPiece
{
};

`OceanMonumentDoubleYZRoom`

struct __cppobj OceanMonumentDoubleYZRoom : OceanMonumentPiece
{
};

`OpCommand`

struct __cppobj OpCommand : ServerCommand
{
  PlayerSelector mTargets;
};

`OffhandContainerController`

struct __cppobj OffhandContainerController : ContainerController
{
};

`OutputContainerController`

struct __cppobj OutputContainerController : ContainerController
{
};