D~1

dragon::rendering::AsyncTasksScope

struct __cppobj dragon::rendering::AsyncTasksScope
{
  MPMCQueue<std::shared_ptr<cg::details::DispatchToken<std::shared_ptr<cg::details::WorkToken const >,std::shared_ptr<std::function<void __cdecl(dragon::rendering::RenderContext &)> > > const > > mAsyncTasks;
  std::atomic<bool> mCompleted;
  cg::details::SpecializedScopedFrame<cg::TaskDispatcher<cg::TaskScheduler<cg::LambdaExecutor<dragon::rendering::RenderContext,cg::TaskPoolGroupExecutionPolicy<dragon::rendering::RenderContext,1>,std::string const &,std::vector<cg::GroupPoolDescription> const &> > >::TaskDispatcherExecution,void> mScopedFrame;
};

dragon::AccelerationStructureResourceService

struct __cppobj dragon::AccelerationStructureResourceService : mce::CheckedResourceService<mce::resource_service_traits<dragon::mesh::ResolvedAccelerationStructureResource,mce::UncheckedHandleTracker,mce::SimpleResourceTracker,mce::AssertResourceServiceErrorHandler,dragon::DragonBufferResourceServiceContext> >
{
};

dragon::rendering::BgfxPrimitiveIndexBuffer

struct __cppobj dragon::rendering::BgfxPrimitiveIndexBuffer
{
  _BYTE mPrimitiveType[4];
  dragon::mesh::IndexBufferResourceManager *mIbManager;
  dragon::IndexBufferResourceService *mIndexBufferResourceService;
  std::optional<dragon::rendering::details::BufferHandleTypeWrapper<dragon::mesh::details::IndexBufferHandleTypeKey,unsigned __int64> > mIndexBuffer;
  dragon::mesh::IndexSize mIndexSize;
  std::vector<unsigned char> mIndices;
  mce::ServerResourcePointer<mce::ResourcePointer<dragon::mesh::ResolvedIndexBufferResource,mce::ResourceBlockTemplate<dragon::mesh::ResolvedIndexBufferResource,mce::UncheckedHandleTracker,dragon::BufferDescription>,std::shared_ptr>,mce::AssertResourceServiceErrorHandler> mServerIndexBuffer;
  unsigned int mCapacity;
  std::mutex mAccess;
};

dragon::materials::MaterialResourceManager::MaterialInitializationOptions

struct __cppobj dragon::materials::MaterialResourceManager::MaterialInitializationOptions
{
  std::string mPathPrefix;
  std::string mPathSuffix;
  std::string mIndexFileName;
  std::function<std::string __cdecl(std::string const &)> mLoadCallback;
  gsl::not_null<dragon::rendering::GraphicsTasks *> mGraphicsTasks;
};

dragon::materials::MaterialRepositoryIndex::Entry

struct __cppobj dragon::materials::MaterialRepositoryIndex::Entry
{
  std::string mFileName;
};

dragon::materials::MaterialResourceManager

struct __cppobj dragon::materials::MaterialResourceManager
{
  std::unique_ptr<TaskGroup> mAsyncLoadMaterialTaskGroup;
  dragon::materials::CompiledMaterialDefinition mEmptyMaterialDefinition;
  std::unordered_map<unsigned __int64,bool> mPendingAsyncLoadingCompiledMaterials;
  cg::ResourceManager<std::unique_ptr<dragon::materials::CompiledMaterialDefinition>,std::string,void,std::unique_ptr<dragon::materials::CompiledMaterialDefinition> *,std::unordered_map> mCompiledMaterials;
  cg::ResourceManager<std::unique_ptr<dragon::materials::Material>,dragon::materials::MaterialLocation,void,std::unique_ptr<dragon::materials::Material> *,std::unordered_map> mRuntimeMaterials;
  dragon::materials::MaterialResourceManager::MaterialInitializationOptions mOptions;
  std::unique_ptr<dragon::materials::MaterialRepositoryIndex> mMaterialsIndex;
  std::atomic<bool> mInitializationComplete;
  std::thread::id mInitializationThreadID;
};

DisableServiceLocatorOverride

struct __cppobj DisableServiceLocatorOverride
{
};

DebugEndPoint

struct __cppobj DebugEndPoint : ContentLogEndPoint, ResourcePackListener
{
  bool mIsVanilla;
  bool mEnabled;
  std::unordered_map<ResourcePackManager *,bool> mResourceManagersInVanilla;
};

DebugEndPoint_vtbl

struct /*VFT*/ DebugEndPoint_vtbl
{
  void (__fastcall *~LogEndPoint)(Bedrock::LogEndPoint *this);
  void (__fastcall *log)(Bedrock::LogEndPoint *this, const char *);
  void (__fastcall *flush)(Bedrock::LogEndPoint *this);
  void (__fastcall *setEnabled)(Bedrock::LogEndPoint *this, bool);
  bool (__fastcall *isEnabled)(Bedrock::LogEndPoint *this);
  void (__fastcall *log)(ContentLogEndPoint *this, const LogArea, const LogLevel, const char *);
  void (__fastcall *contentAssert)(DebugEndPoint *this, const LogArea, const LogLevel, const char *);
};

DebugUdpProxy::DelayedPacket

struct __cppobj DebugUdpProxy::DelayedPacket
{
  char mData[2000];
  int mBytesUsed;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mDelayedUntil;
};

DebugUdpProxy

struct __cppobj __declspec(align(8)) DebugUdpProxy
{
  const std::string mRemoteHost;
  const unsigned __int16 mRemotePort;
  int mExtraFullLatency;
  int mMaxBandwidth;
  float mPacketLossPercent;
  Random mRandom;
  std::atomic<bool> mRunning;
  std::thread mRoutingThread;
  int mOutputSocket;
  std::vector<DebugUdpProxy::DelayedPacket> mIncomingPackets;
  std::vector<DebugUdpProxy::DelayedPacket> mOutgoingPackets;
  std::array<int,10> mIncomingBandwidthHistory;
  std::array<int,10> mOutgoingBandwidthHistory;
  int mCurrentIndex;
  sockaddr_in mDestinationAddress;
  sockaddr_in mSourceAddress;
};

DebugUdpProxyConsumer

struct __cppobj DebugUdpProxyConsumer
{
  std::unique_ptr<DebugUdpProxy> mDebugUdpProxy;
  Bedrock::PubSub::ScopedSubscription mOptionSubscription;
};

DurableTransactionHandler

struct __cppobj DurableTransactionHandler : TransactionHandler
{
  GameStore *mGameStore;
  PurchaseCache *mPurchaseCache;
};

DurableTransactionHandler_vtbl

struct /*VFT*/ DurableTransactionHandler_vtbl
{
  void (__fastcall *~TransactionHandler)(TransactionHandler *this);
  void (__fastcall *update)(TransactionHandler *this);
  void (__fastcall *transactPurchase)(TransactionHandler *this, Offer *, TransactionContext *, PurchasePath);
  bool (__fastcall *transactFulfillment)(TransactionHandler *this, Offer *, std::shared_ptr<Purchase>, std::unique_ptr<TransactionContext>, PurchasePath);
};

DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::EnumClassHash

struct __cppobj DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::EnumClassHash
{
};

DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>

struct __cppobj __declspec(align(8)) DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>
{
  MPMCQueue<std::pair<enum MinecraftGame::DeferredTaskCategory,std::function<void __cdecl(enum DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::Reason)> > > mSubmitQueue;
  std::unordered_multimap<enum MinecraftGame::DeferredTaskCategory,std::function<void __cdecl(enum DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::Reason)>,DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::EnumClassHash,std::equal_to<enum MinecraftGame::DeferredTaskCategory>,std::allocator<std::pair<enum MinecraftGame::DeferredTaskCategory const ,std::function<void __cdecl(enum DeferredTasksManager<enum MinecraftGame::DeferredTaskCategory>::Reason)> > > > mCallbacks;
  std::atomic<bool> mAborted;
};

DeviceButtonMapping

struct __cppobj __declspec(align(8)) DeviceButtonMapping
{
  std::string buttonName;
  int buttonNum;
};

DataDrivenRenderer_tempComponent

struct __cppobj DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer_tempComponent_vtbl *__vftable /*VFT*/;
};

DataDrivenRenderer_tempComponent_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer

struct __cppobj DataDrivenRenderer : ActorRenderer
{
  std::vector<std::unique_ptr<DataDrivenRenderer_tempComponent>> mTempComponents;
  const HashedString mName;
  const bool mIsAttachable;
  mce::TexturePtr mDefaultSkin;
  ExpressionNode mUpdateBonesAndEffectsIfOffScreen;
  ExpressionNode mUpdateEffectsIfOffScreen;
  mce::MaterialPtr mRopeMat;
  mce::TexturePtr mRopeTex;
};

DataDrivenModel

const struct __cppobj __declspec(align(8)) DataDrivenModel : Model
{
  std::shared_ptr<ActorResourceDefinition> mResourceDefinition;
  HashedString mName;
  std::map<int,DataDrivenRenderer *> mItemToRendererMap;
  bool mEnableAttachables;
};

DataDrivenModel_vtbl

struct /*VFT*/ DataDrivenModel_vtbl
{
  void (__fastcall *~AppPlatformListener)(AppPlatformListener *this);
  void (__fastcall *onLowMemory)(AppPlatformListener *this);
  void (__fastcall *onAppPaused)(AppPlatformListener *this);
  void (__fastcall *onAppUnpaused)(AppPlatformListener *this);
  void (__fastcall *onAppPreSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppResumed)(AppPlatformListener *this);
  void (__fastcall *onAppFocusLost)(AppPlatformListener *this);
  void (__fastcall *onAppFocusGained)(AppPlatformListener *this);
  void (__fastcall *onAppTerminated)(AppPlatformListener *this);
  void (__fastcall *onOperationModeChanged)(AppPlatformListener *this, const OperationMode);
  void (__fastcall *onPerformanceModeChanged)(AppPlatformListener *this, const bool);
  void (__fastcall *onPushNotificationReceived)(AppPlatformListener *this, const PushNotificationMessage *);
  void (__fastcall *onResizeBegin)(AppPlatformListener *this);
  void (__fastcall *onResizeEnd)(AppPlatformListener *this);
  void (__fastcall *onDeviceLost)(AppPlatformListener *this);
  void (__fastcall *clear)(Model *this);
  void (__fastcall *preDraw)(Model *this, ScreenContext *);
  void (__fastcall *postDraw)(Model *this, ScreenContext *);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *);
  void (__fastcall *render)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, ScreenContext *);
  void (__fastcall *setupAnim)(Model *this);
  void (__fastcall *setupAnim)(Model *this, float, float, float, float, float, float);
  void (__fastcall *prepareMobModel)(Model *this, Mob *, float, float, float);
  Vec3 *(__fastcall *getLeashOffsetPosition)(Model *this, Vec3 *result, bool);
  void (__fastcall *renderAniModel)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  void (__fastcall *renderMod)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *youngTransform)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  float (__fastcall *getHeightAdjustment)(Model *this);
  AABB *(__fastcall *buildAABB)(Model *this, AABB *result);
};

DressingRoomManifestCustom

struct __cppobj DressingRoomManifestCustom
{
  persona::CategoryQueryDocument mDressingRoomMainFeaturedQueryDocument;
  persona::CategoryQueryDocument mProfileFeaturedQueryDocument;
  persona::CategoryQueryDocument mSkinPackFeaturedQueryDocument;
  std::vector<persona::CategoryDocument> mCategoryDocuments;
};

DressingRoomManifestDocument

struct __cppobj DressingRoomManifestDocument
{
  CommonDocument mCommon;
  DressingRoomManifestCustom mCustom;
};

DressingRoomManifestSearchResults

const struct __cppobj DressingRoomManifestSearchResults : CommonSearchResults
{
  std::vector<DressingRoomManifestDocument> mDocuments;
};

DressingRoomTreatmentQuery

struct __cppobj __declspec(align(8)) DressingRoomTreatmentQuery : TreatmentQuery<DressingRoomManifestSearchResults,DressingRoomManifestDocument>
{
  std::function<void __cdecl(DressingRoomManifestCustom const &)> mOnQueryFinishedCallbeck;
  bool mHasFetchedContent;
  bool mHasRecievedManifest;
  bool mLocalizationReady;
};

DressingRoomTreatmentQuery_vtbl

struct /*VFT*/ DressingRoomTreatmentQuery_vtbl
{
  void (__fastcall *~TreatmentQuery<DressingRoomManifestSearchResults,DressingRoomManifestDocument>)(TreatmentQuery<DressingRoomManifestSearchResults,DressingRoomManifestDocument> *this);
  const std::string *(__fastcall *getDocumentId)(TreatmentQuery<DressingRoomManifestSearchResults,DressingRoomManifestDocument> *this);
  void (__fastcall *_processQueryResults)(TreatmentQuery<DressingRoomManifestSearchResults,DressingRoomManifestDocument> *this, const DressingRoomManifestSearchResults *, const std::vector<std::string> *);
};

DBStorage::Options

struct __cppobj __declspec(align(8)) DBStorage::Options
{
  leveldb::Options options;
  leveldb::ReadOptions read;
  leveldb::WriteOptions write;
};

DBStorage

struct __cppobj DBStorage : LevelStorage
{
  std::unique_ptr<DBStorageEnvironmentChain> mEnvChain;
  std::unique_ptr<leveldb::Cache> mCache;
  std::unique_ptr<leveldb::FilterPolicy const > mFilterPolicy;
  std::unique_ptr<leveldb::Compressor> mCompressor;
  std::unique_ptr<leveldb::Compressor> mLegacyCompressor;
  std::unique_ptr<DBStorage::Options> mOptions;
  std::unique_ptr<leveldb::DecompressAllocator> mDecompressAllocator;
  std::unique_ptr<leveldb::DB> mDb;
  std::unique_ptr<TaskGroup> mIOTaskGroup;
  std::unique_ptr<TaskGroup> mCompactionTaskGroup;
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mCompactionTask;
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mWriteTask;
  Core::LevelStorageResult mState;
  Core::PathBuffer<std::string > mFullPath;
  Core::PathBuffer<std::string > mDbPath;
  std::string mLevelId;
  std::mutex mCompactionMutex;
  std::shared_mutex mWriteCacheMutex;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mLastCompactionStartTime;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mCompactionInterval;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mWriteFlushInterval;
  std::atomic<bool> mAllowFlush;
  std::atomic<bool> mSavingInProgress;
  std::atomic<bool> mSnapshotInProgress;
  std::atomic<bool> mShutdownStarted;
  std::atomic<bool> mNoMoreWrites;
  std::atomic<bool> mShutdownDone;
  std::atomic<int> mOutstandingJobs;
  std::shared_ptr<SaveTransactionManager> msptSaveTransactionManager;
  std::function<void __cdecl(void)> mCriticalSyncSaveCallback;
  std::function<void __cdecl(enum CompactionStatus)> mExternallyRegisteredCompactionCallback;
  SmallSet<DBChunkStorage *> mChunkStorages;
  std::vector<std::unique_ptr<LevelStorageObserver>> mObservers;
  std::atomic<bool> mDestructorInProgress;
  bool mForceCorrupt;
  const bool mStorageEnabled;
  Core::PathBuffer<std::string > mDbSubfolder;
  LevelStorageWriteBatch mSingleKeyWrites;
  std::vector<LevelStorageWriteBatch> mBatchWrites;
};

DBChunkStorage

struct __cppobj __declspec(align(8)) DBChunkStorage : ChunkSource
{
  std::unordered_map<DBChunkStorageKey,enum DBChunkStorage::ChunkCacheStatus> mHasChunkCache;
  SpinLock mHasChunkCacheMutex;
  DBStorage *mStorage;
  std::vector<std::shared_ptr<LevelStorageWriteBatch>> mBufferPool;
  std::vector<std::unique_ptr<LevelChunk,LevelChunkFinalDeleter>> mDiscardBatch;
  std::unordered_set<ChunkPos> mLiveChunksBeingSaved;
  std::unordered_map<ChunkPos,std::unique_ptr<LevelChunk,LevelChunkFinalDeleter>> mDiscardedWhileLiveSaved;
  bool mBatch;
  std::unique_ptr<TaskGroup> mIOTaskGroup;
  int mLastSavedChunkVersion;
};

DBChunkStorage_vtbl

struct /*VFT*/ DBChunkStorage_vtbl
{
  void (__fastcall *~ChunkSource)(ChunkSource *this);
  void (__fastcall *shutdown)(ChunkSource *this);
  bool (__fastcall *isShutdownDone)(ChunkSource *this);
  std::shared_ptr<LevelChunk> *(__fastcall *getExistingChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *);
  std::shared_ptr<LevelChunk> *(__fastcall *getRandomChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, Random *);
  std::shared_ptr<LevelChunk> *(__fastcall *createNewChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *, ChunkSource::LoadMode);
  std::shared_ptr<LevelChunk> *(__fastcall *getOrLoadChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *, ChunkSource::LoadMode);
  bool (__fastcall *postProcess)(ChunkSource *this, ChunkViewSource *);
  void (__fastcall *checkAndReplaceChunk)(ChunkSource *this, ChunkViewSource *, LevelChunk *);
  void (__fastcall *loadChunk)(ChunkSource *this, LevelChunk *, bool);
  void (__fastcall *postProcessMobsAt)(ChunkSource *this, BlockSource *, int, int, Random *);
  bool (__fastcall *saveLiveChunk)(ChunkSource *this, LevelChunk *);
  void (__fastcall *hintDiscardBatchBegin)(ChunkSource *this);
  void (__fastcall *hintDiscardBatchEnd)(ChunkSource *this);
  void (__fastcall *acquireDiscarded)(ChunkSource *this, std::unique_ptr<LevelChunk,LevelChunkFinalDeleter>);
  void (__fastcall *compact)(ChunkSource *this);
  void (__fastcall *flushPendingWrites)(ChunkSource *this);
  bool (__fastcall *isWithinWorldLimit)(ChunkSource *this, const ChunkPos *);
  const std::unordered_map<ChunkPos,std::weak_ptr<LevelChunk>> *(__fastcall *getChunkMap)(ChunkSource *this);
  const std::unordered_map<ChunkPos,std::weak_ptr<LevelChunk>> *(__fastcall *getStorage)(ChunkSource *this);
  void (__fastcall *clearDeletedEntities)(ChunkSource *this);
  void (__fastcall *removeDimensionData)(ChunkSource *this, const std::unordered_set<AutomaticID<Dimension,int>> *);
  bool (__fastcall *hasChunk)(ChunkSource *this, const ChunkPos *, AutomaticID<Dimension,int>);
  bool (__fastcall *canCreateViews)(ChunkSource *this);
};

DBStorage_vtbl

struct /*VFT*/ DBStorage_vtbl
{
  void (__fastcall *~LevelStorage)(LevelStorage *this);
  void (__fastcall *addStorageObserver)(LevelStorage *this, std::unique_ptr<LevelStorageObserver>);
  std::unique_ptr<CompoundTag> *(__fastcall *getCompoundTag)(LevelStorage *this, std::unique_ptr<CompoundTag> *result, const std::string *);
  bool (__fastcall *hasKey)(LevelStorage *this, gsl::basic_string_span<char const ,-1>);
  void (__fastcall *forEachKeyWithPrefix)(LevelStorage *this, gsl::basic_string_span<char const ,-1>, const std::function<void __cdecl(gsl::basic_string_span<char const ,-1>,gsl::basic_string_span<char const ,-1>)> *);
  bool (__fastcall *loadLevelData)(LevelStorage *this, LevelData *);
  std::unique_ptr<ChunkSource> *(__fastcall *createChunkStorage)(LevelStorage *this, std::unique_ptr<ChunkSource> *result, std::unique_ptr<ChunkSource>, StorageVersion);
  void (__fastcall *saveLevelData)(LevelStorage *this, const LevelData *);
  const Core::PathBuffer<std::string > *(__fastcall *getFullPath)(LevelStorage *this);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *saveData)(LevelStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, const LevelStorageWriteBatch *);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *saveData)(LevelStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, const std::string *, std::string *);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *deleteData)(LevelStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, const std::string *);
  void (__fastcall *syncIO)(LevelStorage *this);
  void (__fastcall *getStatistics)(LevelStorage *this, std::string *);
  bool (__fastcall *clonePlayerData)(LevelStorage *this, gsl::basic_string_span<char const ,-1>, gsl::basic_string_span<char const ,-1>);
  Core::LevelStorageResult *(__fastcall *getLevelStorageState)(LevelStorage *this, Core::LevelStorageResult *result);
  void (__fastcall *startShutdown)(LevelStorage *this);
  bool (__fastcall *isShuttingDown)(LevelStorage *this);
  bool (__fastcall *checkShutdownDone)(LevelStorage *this);
  bool (__fastcall *loadData)(LevelStorage *this, gsl::basic_string_span<char const ,-1>, std::string *);
  Core::LevelStorageResult *(__fastcall *getState)(LevelStorage *this, Core::LevelStorageResult *result);
  std::vector<SnapshotFilenameAndLength> *(__fastcall *createSnapshot)(LevelStorage *this, std::vector<SnapshotFilenameAndLength> *result, const std::string *);
  void (__fastcall *releaseSnapshot)(LevelStorage *this);
  void (__fastcall *compactStorage)(LevelStorage *this);
  void (__fastcall *syncAndSuspendStorage)(LevelStorage *this);
  void (__fastcall *resumeStorage)(LevelStorage *this);
  void (__fastcall *setFlushAllowed)(LevelStorage *this, bool);
  void (__fastcall *flushToPermanentStorage)(LevelStorage *this);
  void (__fastcall *freeCaches)(LevelStorage *this);
  void (__fastcall *setCompactionCallback)(LevelStorage *this, std::function<void __cdecl(enum CompactionStatus)>);
  void (__fastcall *setCriticalSyncSaveCallback)(LevelStorage *this, std::function<void __cdecl(void)>);
  void (__fastcall *corruptLevel)(LevelStorage *this);
};

DynamicPackageControl

struct __cppobj __declspec(align(8)) DynamicPackageControl
{
  std::unique_ptr<Bedrock::DynamicPackage::DynamicPackageManager> mDynamicPackageManager;
  std::unique_ptr<DynamicPackageControl::ManagerListenerProxy> mListenerProxy;
  IDynamicPackageConsumer *mConsumer;
  bool mIsMounted;
};

DynamicPackageControl::ManagerListenerProxy

struct __cppobj DynamicPackageControl::ManagerListenerProxy : Bedrock::DynamicPackage::DynamicPackageManagerListener
{
  DynamicPackageControl *mControl;
};

DynamicPackageControl::ManagerListenerProxy_vtbl

struct /*VFT*/ DynamicPackageControl::ManagerListenerProxy_vtbl
{
  void (__fastcall *~DynamicPackageManagerListener)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this);
  void (__fastcall *onInitializeComplete)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this);
  void (__fastcall *onCheckFileResult)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this, const Bedrock::DynamicPackage::CheckFilesResult *);
  void (__fastcall *onMountStateChanged)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this, const Bedrock::DynamicPackage::MountState *);
  void (__fastcall *onDownloadStarted)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this, const Bedrock::DynamicPackage::DownloadState *);
  void (__fastcall *onDownloadStateChanged)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this, const Bedrock::DynamicPackage::DownloadState *);
  void (__fastcall *onDownloadCompleted)(Bedrock::DynamicPackage::DynamicPackageManagerListener *this, const Bedrock::DynamicPackage::DownloadState *);
};

DimensionBrightnessRamp

const struct __cppobj DimensionBrightnessRamp
{
  DimensionBrightnessRamp_vtbl *__vftable /*VFT*/;
  float mBrightnessRamp[16];
};

DimensionBrightnessRamp_vtbl

struct /*VFT*/ DimensionBrightnessRamp_vtbl
{
  void (__fastcall *~DimensionBrightnessRamp)(DimensionBrightnessRamp *this);
  void (__fastcall *buildBrightnessRamp)(DimensionBrightnessRamp *this);
  float (__fastcall *getBaseAmbientValue)(DimensionBrightnessRamp *this);
};

DefintionDescription_vtbl

struct /*VFT*/ DefintionDescription_vtbl
{
  void (__fastcall *~DefintionDescription)(DefintionDescription *this);
  const char *(__fastcall *getJsonName)(DefintionDescription *this);
};

DrinkPotionData

struct __cppobj DrinkPotionData
{
  int mPotionId;
  float mChance;
  ActorFilterGroup mFilter;
};

DwellerDescription

struct __cppobj __declspec(align(8)) DwellerDescription : ComponentDescription
{
  std::string mType;
  std::string mRole;
  std::string mPreferredProfession;
  int mUpdateBase;
  int mUpdateVariant;
  int mFirstFoundingReward;
  float mDwellingBoundsTolerance;
  bool mCanFindPOI;
  bool mCanMigrate;
};

DwellerDescription_vtbl

struct /*VFT*/ DwellerDescription_vtbl
{
  const char *(__fastcall *getJsonName)(Description *this);
  void (__fastcall *~Description)(Description *this);
  void (__fastcall *deserializeData)(Description *this, DeserializeDataParams);
  void (__fastcall *serializeData)(Description *this, Json::Value *);
};

DynamicJumpControlDescription

struct __cppobj DynamicJumpControlDescription : ComponentDescription
{
};

DynamicJumpControlDescription_vtbl

struct /*VFT*/ DynamicJumpControlDescription_vtbl
{
  const char *(__fastcall *getJsonName)(Description *this);
  void (__fastcall *~Description)(Description *this);
  void (__fastcall *deserializeData)(Description *this, DeserializeDataParams);
  void (__fastcall *serializeData)(Description *this, Json::Value *);
};

DistanceSortedActor

struct __declspec(align(8)) DistanceSortedActor
{
  Actor *mActor;
  float mDistanceSquared;
};

DataTypeMap::neqFor<CompoundTag>

struct __cppobj DataTypeMap::neqFor<CompoundTag>
{
};

DataTypeMap::copyFor<CompoundTag>

struct __cppobj DataTypeMap::copyFor<CompoundTag>
{
};

DefaultEmptyActorAnimationPlayer

struct __cppobj DefaultEmptyActorAnimationPlayer : ActorAnimationPlayer
{
};

DefaultEmptyActorAnimationPlayer_vtbl

struct /*VFT*/ DefaultEmptyActorAnimationPlayer_vtbl
{
  void (__fastcall *~ActorAnimationPlayer)(ActorAnimationPlayer *this);
  void (__fastcall *applyToPose)(ActorAnimationPlayer *this, RenderParams *, std::unordered_map<enum SkeletalHierarchyIndex,std::vector<BoneOrientation>> *, float);
  void (__fastcall *resetAnimation)(ActorAnimationPlayer *this);
  void (__fastcall *buildBoneToPartMapping)(ActorAnimationPlayer *this, AnimationComponent *);
  void (__fastcall *bindParticleEffects)(ActorAnimationPlayer *this, const std::unordered_map<HashedString,ParticleEffectPtr> *);
  void (__fastcall *bindSoundEffects)(ActorAnimationPlayer *this, const std::unordered_map<HashedString,std::string> *);
  bool (__fastcall *hasAnimationFinished)(ActorAnimationPlayer *this);
  ActorAnimationPlayer *(__fastcall *findAnimation)(ActorAnimationPlayer *this, const HashedString *);
  ActorAnimationType (__fastcall *getAnimationType)(ActorAnimationPlayer *this);
  void (__fastcall *updateBoneToPartMapping)(ActorAnimationPlayer *this, AnimationComponent *);
};

DataTypeMap::typeFor<signed char>

struct __cppobj DataTypeMap::typeFor<signed char>
{
};

DataTypeMap::typeFor<short>

struct __cppobj DataTypeMap::typeFor<short>
{
};

DataTypeMap::typeFor<int>

struct __cppobj DataTypeMap::typeFor<int>
{
};

DataTypeMap::typeFor<float>

struct __cppobj DataTypeMap::typeFor<float>
{
};

DataTypeMap::typeFor<std::string >

struct __cppobj DataTypeMap::typeFor<std::string >
{
};

DataTypeMap::typeFor<CompoundTag>

struct __cppobj DataTypeMap::typeFor<CompoundTag>
{
};

DataTypeMap::typeFor<BlockPos>

struct __cppobj DataTypeMap::typeFor<BlockPos>
{
};

DataTypeMap::typeFor<Vec3>

struct __cppobj DataTypeMap::typeFor<Vec3>
{
};

DataTypeMap::typeFor<__int64>

struct __cppobj DataTypeMap::typeFor<__int64>
{
};

Direction

struct __cppobj Direction
{
};

DebugUdpProxyConsumer::setupOptions::__l2::<lambda_c3dd6988f427fbf3ca837219cd585471>

struct __cppobj DebugUdpProxyConsumer::setupOptions::__l2::<lambda_c3dd6988f427fbf3ca837219cd585471>
{
  DebugUdpProxyConsumer *const __this;
  const std::shared_ptr<Options> options;
};

DropdownScreenController

struct __cppobj __declspec(align(8)) DropdownScreenController : ScreenController
{
  int mOffset;
  std::vector<bool> mActiveDropdown;
  bool mUpdateBindings;
};

DropdownScreenController_vtbl

struct /*VFT*/ DropdownScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
};

DlcChecker

struct __cppobj DlcChecker
{
  bool mStorageCheckActive;
};

DlcValidationState

struct __cppobj __declspec(align(2)) DlcValidationState : IDlcValidationState
{
  std::string mLevelId;
  std::vector<DlcId> mDlcIds;
  DlcId mWorldTemplateDlcId;
  std::vector<std::string> mProductTitles;
  std::string mWorldTemplateTitle;
  std::function<void __cdecl(void)> mCallback;
  std::vector<DlcDependency> mPackDependencies;
  std::vector<PackIdVersion> mOwnedMissingPackIds;
  std::vector<DlcId> mDlcToDownload;
  LevelData *mLevelDataPtr;
  bool mOwnershipBypassEnabled;
  bool mShowCancelOnPurchasePrompt;
  bool mShowProgressScreen;
  bool mShowCloseButton;
  bool mRequireCancelToExit;
  bool mSkipPurchase;
  bool mStorageCheckComplete;
  bool mStorageSpaceAvailable;
  unsigned __int64 mStorageSpaceNeeded;
  bool mDlcTitlesFetched;
  bool mWorldTemplateTitleFetched;
  bool mEnableMissingContentCheck;
  bool mEnableMissingWorldTemplateCheck;
  bool mAllowDownloadNoWifi;
  bool mIgnorePerfIssues;
  bool mShowDownloadPrompt;
  bool mIsUpdate;
  bool mDlcDownloadChecked;
  bool mWorldTemplateDownloadChecked;
  bool mDoWorldTemplateCopiedCheck;
  bool mRequiresCopiedPackRemovalCheck;
  bool mHasMissingOwnedWorldTemplateDlc;
  bool mHasMissingOwnedContent;
  bool mProcessingPendingImports;
};

DlcValidationState_vtbl

struct /*VFT*/ DlcValidationState_vtbl
{
  void (__fastcall *~IDlcValidationState)(IDlcValidationState *this);
};

DlcUIWrapper

struct __cppobj DlcUIWrapper
{
  std::unique_ptr<DlcChecker> mDlcChecker;
  std::shared_ptr<bool> mExistenceTracker;
  ContentAcquisition *mContentAcquisition;
  std::shared_ptr<DlcValidationState> mDlcState;
  std::function<void __cdecl(void)> mOnCompleteCallback;
  EnteringGameState mEnteringGameState;
  MainMenuScreenController *mMainMenuScreenController;
  MainMenuScreenModel *mMainMenuScreenModel;
  IDlcValidation *mDlcValidation;
  IDlcBatcher *mDlcBatcher;
  WorldTemplateManager *mWorldTemplateManager;
  LevelListCache *mLevelListCache;
  ContentManager *mContentManager;
};

DataBindingComponent

struct __cppobj __declspec(align(8)) DataBindingComponent : UIComponent
{
  std::vector<DataBindingComponent::DataBinding> mBindings;
  std::vector<DataBindingComponent::DataBinding> mPriorityBindings;
  std::vector<DataBindingComponent::DataBinding> mAlwaysBindings;
  bool mDirty;
};

DataBindingComponent_vtbl

struct /*VFT*/ DataBindingComponent_vtbl
{
  void (__fastcall *~UIComponent)(UIComponent *this);
  void (__fastcall *OnScreenPop)(UIComponent *this);
  std::unique_ptr<UIComponent> *(__fastcall *clone)(UIComponent *this, std::unique_ptr<UIComponent> *result, UIControl *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, const ScreenEvent *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, VisualTree *, ScreenInputContext *, UIAnimationController *, const ScreenEvent *);
  void (__fastcall *onNotifyChildAdded)(UIComponent *this);
  void (__fastcall *onNotifyChildRemoved)(UIComponent *this);
  void (__fastcall *onRemoved)(UIComponent *this);
  void (__fastcall *onAdded)(UIComponent *this);
  void (__fastcall *onVisibilityChanged)(UIComponent *this, bool);
  void (__fastcall *onEnabledChanged)(UIComponent *this, bool);
  bool (__fastcall *isRenderableComponent)(UIComponent *this);
  bool (__fastcall *onLayoutChange)(UIComponent *this);
  void (__fastcall *reset)(UIComponent *this);
  void (__fastcall *reload)(UIComponent *this, const UIComponent *);
  const std::string *(__fastcall *getTextToSpeechComponentValue)(UIComponent *this);
};

Detail::HashHelper<char [39]>

struct __cppobj Detail::HashHelper<char [39]>
{
};

Detail::HashHelper<char [23]>

struct __cppobj Detail::HashHelper<char [23]>
{
};

Detail::HashHelper<char [28]>

struct __cppobj Detail::HashHelper<char [28]>
{
};

Detail::HashHelper<char [21]>

struct __cppobj Detail::HashHelper<char [21]>
{
};

Detail::HashHelper<char [25]>

struct __cppobj Detail::HashHelper<char [25]>
{
};

Detail::HashHelper<char [24]>

struct __cppobj Detail::HashHelper<char [24]>
{
};

Detail::HashHelper<char [33]>

struct __cppobj Detail::HashHelper<char [33]>
{
};

Detail::HashHelper<char [22]>

struct __cppobj Detail::HashHelper<char [22]>
{
};

Detail::HashHelper<char [27]>

struct __cppobj Detail::HashHelper<char [27]>
{
};

Detail::HashHelper<char [20]>

struct __cppobj Detail::HashHelper<char [20]>
{
};

Detail::HashHelper<char [35]>

struct __cppobj Detail::HashHelper<char [35]>
{
};

Detail::HashHelper<char [17]>

struct __cppobj Detail::HashHelper<char [17]>
{
};

Detail::HashHelper<char [9]>

struct __cppobj Detail::HashHelper<char [9]>
{
};

Detail::HashHelper<char [36]>

struct __cppobj Detail::HashHelper<char [36]>
{
};

Detail::HashHelper<char [38]>

struct __cppobj Detail::HashHelper<char [38]>
{
};

Detail::HashHelper<char [19]>

struct __cppobj Detail::HashHelper<char [19]>
{
};

Detail::HashHelper<char [10]>

struct __cppobj Detail::HashHelper<char [10]>
{
};

Detail::HashHelper<char [29]>

struct __cppobj Detail::HashHelper<char [29]>
{
};

Detail::HashHelper<char [26]>

struct __cppobj Detail::HashHelper<char [26]>
{
};

Detail::HashHelper<char [11]>

struct __cppobj Detail::HashHelper<char [11]>
{
};

Detail::HashHelper<char [15]>

struct __cppobj Detail::HashHelper<char [15]>
{
};

Detail::HashHelper<char [18]>

struct __cppobj Detail::HashHelper<char [18]>
{
};

Detail::HashHelper<char [30]>

struct __cppobj Detail::HashHelper<char [30]>
{
};

Detail::HashHelper<char [37]>

struct __cppobj Detail::HashHelper<char [37]>
{
};

Detail::HashHelper<char [40]>

struct __cppobj Detail::HashHelper<char [40]>
{
};

Detail::HashHelper<char [51]>

struct __cppobj Detail::HashHelper<char [51]>
{
};

Detail::HashHelper<char [14]>

struct __cppobj Detail::HashHelper<char [14]>
{
};

DlcUIWrapper::_checkForCopiedPremiumWorldTemplate::__l37::<lambda_fc643eb1f55d42056a3879110db88448>

struct __cppobj DlcUIWrapper::_checkForCopiedPremiumWorldTemplate::__l37::<lambda_fc643eb1f55d42056a3879110db88448>
{
  PackIdVersion *candidateId;
  const PackIdVersion *worldTemplateId;
  WorldHistoryPackSource **historyPackSource;
};

DlcUIWrapper::_checkForCopiedPremiumWorldTemplate::__l24::<lambda_00263350a0caeba33e3799a113a0fdf4>

struct __cppobj DlcUIWrapper::_checkForCopiedPremiumWorldTemplate::__l24::<lambda_00263350a0caeba33e3799a113a0fdf4>
{
  std::vector<DlcDependency> *packDeletionCandidates;
  const PackIdVersion *packIdDependency;
  DlcDependency *packDependency;
};

DlcUIWrapper::tick::__l86::<lambda_1535f8725abc34f742e4a30613ae126f>

struct __cppobj DlcUIWrapper::tick::__l86::<lambda_1535f8725abc34f742e4a30613ae126f>
{
  std::weak_ptr<bool> weakTracker;
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l86::<lambda_1535f8725abc34f742e4a30613ae126f>::()::__l19::<lambda_1f0ee474cb73320e8f2f42eb44ccc775>

struct __cppobj DlcUIWrapper::tick::__l86::<lambda_1535f8725abc34f742e4a30613ae126f>::()::__l19::<lambda_1f0ee474cb73320e8f2f42eb44ccc775>
{
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l70::<lambda_fec166a1f5820505f96b2047263cb659>

struct __cppobj DlcUIWrapper::tick::__l70::<lambda_fec166a1f5820505f96b2047263cb659>
{
};

DlcUIWrapper::tick::__l73::<lambda_2c18c32c22b148a005e5f4d893e06c99>

struct __cppobj DlcUIWrapper::tick::__l73::<lambda_2c18c32c22b148a005e5f4d893e06c99>
{
  DlcUIWrapper::tick::__l70::<lambda_fec166a1f5820505f96b2047263cb659> populateDlcToDownload;
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l59::<lambda_39e6299c0d520eb3fbee64d2d3d6bfa4>

struct __cppobj DlcUIWrapper::tick::__l59::<lambda_39e6299c0d520eb3fbee64d2d3d6bfa4>
{
  DlcUIWrapper *const __this;
  std::weak_ptr<bool> weakTracker;
};

DlcUIWrapper::tick::__l58::<lambda_60f23828f0d7604993f7eea9ab594137>::()::__l18::<lambda_3da1a2fce128e96552c77fa5a56fcfc0>

struct __cppobj DlcUIWrapper::tick::__l58::<lambda_60f23828f0d7604993f7eea9ab594137>::()::__l18::<lambda_3da1a2fce128e96552c77fa5a56fcfc0>
{
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l58::<lambda_60f23828f0d7604993f7eea9ab594137>::()::__l16::<lambda_b1c39dfb11c63a520ebab07f7f2b526c>

struct __cppobj DlcUIWrapper::tick::__l58::<lambda_60f23828f0d7604993f7eea9ab594137>::()::__l16::<lambda_b1c39dfb11c63a520ebab07f7f2b526c>
{
};

DlcUIWrapper::tick::__l57::<lambda_8cbc743a3b58bf98163f7b11a23e5f34>

struct __cppobj DlcUIWrapper::tick::__l57::<lambda_8cbc743a3b58bf98163f7b11a23e5f34>
{
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l56::<lambda_e3efaa7fe1c2091e53abe9178d500316>

struct __cppobj DlcUIWrapper::tick::__l56::<lambda_e3efaa7fe1c2091e53abe9178d500316>
{
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l54::<lambda_19ce5a0744c227af7ea25e104bf0fd14>

struct __cppobj DlcUIWrapper::tick::__l54::<lambda_19ce5a0744c227af7ea25e104bf0fd14>
{
};

DlcUIWrapper::tick::__l15::<lambda_7d54067bd42b781e9aa1d47c9b8b16af>

struct __cppobj DlcUIWrapper::tick::__l15::<lambda_7d54067bd42b781e9aa1d47c9b8b16af>
{
  DlcUIWrapper *const __this;
  std::weak_ptr<bool> weakTracker;
};

DlcUIWrapper::tick::__l43::<lambda_c9e5e2f2458024ee4d3a85135bd2e691>

struct __cppobj DlcUIWrapper::tick::__l43::<lambda_c9e5e2f2458024ee4d3a85135bd2e691>
{
  DlcUIWrapper *const __this;
  const std::vector<PackIdVersion> packIds;
  std::weak_ptr<bool> weak;
};

DlcUIWrapper::tick::__l30::<lambda_afc6b6064dfbe6ff78706263072a1c0c>

struct __cppobj DlcUIWrapper::tick::__l30::<lambda_afc6b6064dfbe6ff78706263072a1c0c>
{
  std::weak_ptr<bool> weak;
  DlcUIWrapper *const __this;
};

DlcUIWrapper::tick::__l7::<lambda_704bb1ae1d44a33e52db52fc93a78ab3>

struct __cppobj DlcUIWrapper::tick::__l7::<lambda_704bb1ae1d44a33e52db52fc93a78ab3>
{
  DlcUIWrapper *const __this;
  std::weak_ptr<bool> weakExistence;
};

dragon::RenderMetadataFactory

struct __cppobj dragon::RenderMetadataFactory
{
};

DirectActorProxyImpl<IPlayerMovementProxy>

struct __cppobj DirectActorProxyImpl<IPlayerMovementProxy> : IPlayerMovementProxy, IBoatMovementProxy
{
  Actor *mActor;
  std::shared_ptr<IActorMovementProxy> mRide;
  std::vector<std::shared_ptr<IActorMovementProxy>> mFetchResults;
};

DirectMobMovementProxyImpl<IPlayerMovementProxy>

struct __cppobj DirectMobMovementProxyImpl<IPlayerMovementProxy> : DirectActorProxyImpl<IPlayerMovementProxy>
{
};

DirectPlayerMovementProxy

struct __cppobj DirectPlayerMovementProxy : DirectMobMovementProxyImpl<IPlayerMovementProxy>
{
};

DirectClientInstanceProxy

struct __cppobj DirectClientInstanceProxy : IClientInstanceProxy
{
  IClientInstance *mClient;
};

DirectClientInstanceProxy_vtbl

struct /*VFT*/ DirectClientInstanceProxy_vtbl
{
  void (__fastcall *~IClientInstanceProxy)(IClientInstanceProxy *this);
  bool (__fastcall *isInGame)(IClientInstanceProxy *this);
  bool (__fastcall *isHoloRealityMode)(IClientInstanceProxy *this);
  bool (__fastcall *isRealityFullVRMode)(IClientInstanceProxy *this);
  bool (__fastcall *isVRMode)(IClientInstanceProxy *this);
  Vec3 *(__fastcall *getTransformZDir)(IClientInstanceProxy *this, Vec3 *result, TransformSpace, TransformSpace, TransformSpace);
  bool (__fastcall *isDebugCameraControlActive)(IClientInstanceProxy *this);
  bool (__fastcall *isSame)(IClientInstanceProxy *this, const IClientInstance *);
};

DirectActorProxyImpl<IMobMovementProxy>

struct __cppobj DirectActorProxyImpl<IMobMovementProxy> : IMobMovementProxy, IBoatMovementProxy
{
  Actor *mActor;
  std::shared_ptr<IActorMovementProxy> mRide;
  std::vector<std::shared_ptr<IActorMovementProxy>> mFetchResults;
};

DirectMobMovementProxyImpl<IMobMovementProxy>

struct __cppobj DirectMobMovementProxyImpl<IMobMovementProxy> : DirectActorProxyImpl<IMobMovementProxy>
{
};

DirectActorProxyImpl<IActorMovementProxy>

struct __cppobj DirectActorProxyImpl<IActorMovementProxy> : IActorMovementProxy, IBoatMovementProxy
{
  Actor *mActor;
  std::shared_ptr<IActorMovementProxy> mRide;
  std::vector<std::shared_ptr<IActorMovementProxy>> mFetchResults;
};

DirectActorProxyImpl<IActorMovementProxy>_vtbl

struct /*VFT*/ DirectActorProxyImpl<IActorMovementProxy>_vtbl
{
  void (__fastcall *~IActorMovementProxy)(IActorMovementProxy *this);
  float (__fastcall *getGravity)(IActorMovementProxy *this);
  float (__fastcall *getLevelGravity)(IActorMovementProxy *this);
  bool (__fastcall *isRiding)(IActorMovementProxy *this);
  bool (__fastcall *isClientSide)(IActorMovementProxy *this);
  bool (__fastcall *isCreative)(IActorMovementProxy *this);
  bool (__fastcall *isInWater)(IActorMovementProxy *this);
  bool (__fastcall *isInLava)(IActorMovementProxy *this);
  bool (__fastcall *isInScaffolding)(IActorMovementProxy *this);
  bool (__fastcall *isOverScaffolding)(IActorMovementProxy *this);
  bool (__fastcall *isSwimming)(IActorMovementProxy *this);
  bool (__fastcall *isImmersedInWater)(IActorMovementProxy *this);
  bool (__fastcall *onClimbableBlock)(IActorMovementProxy *this);
  bool (__fastcall *onHoverableBlock)(IActorMovementProxy *this);
  bool (__fastcall *isHeadInWater)(IActorMovementProxy *this);
  bool (__fastcall *canBeginOrContinueClimbingLadder)(IActorMovementProxy *this);
  bool (__fastcall *isSwimmer)(IActorMovementProxy *this);
  bool (__fastcall *isImmobile)(IActorMovementProxy *this);
  bool (__fastcall *isControlledByLocalInstance)(IActorMovementProxy *this);
  bool (__fastcall *hasTeleported)(IActorMovementProxy *this);
  bool (__fastcall *usesOneWayCollision)(IActorMovementProxy *this);
  bool (__fastcall *isStuckInCollider)(IActorMovementProxy *this);
  void (__fastcall *setStuckInCollider)(IActorMovementProxy *this, bool);
  bool (__fastcall *isStuckItem)(IActorMovementProxy *this);
  const std::vector<AABB> *(__fastcall *getOnewayPhysicsBlocks)(IActorMovementProxy *this);
  bool (__fastcall *wasPenetratingLastFrame)(IActorMovementProxy *this);
  void (__fastcall *setWasPenetratingLastFrame)(IActorMovementProxy *this, bool);
  bool (__fastcall *isPrimaryLocalPlayer)(IActorMovementProxy *this);
  const std::vector<AABB> *(__fastcall *getSubAABBs)(IActorMovementProxy *this);
  void (__fastcall *setSubAABBs)(IActorMovementProxy *this, const std::vector<AABB> *);
  bool (__fastcall *isStackable)(IActorMovementProxy *this);
  void (__fastcall *testForEntityStacking)(IActorMovementProxy *this, const AABB *, std::vector<AABB> *);
  bool (__fastcall *getCollidableMobNear)(IActorMovementProxy *this);
  void (__fastcall *setCollidableMobNear)(IActorMovementProxy *this, bool);
  void (__fastcall *testForCollidableMobs)(IActorMovementProxy *this, const AABB *, std::vector<AABB> *);
  float (__fastcall *getWalkDist)(IActorMovementProxy *this);
  void (__fastcall *setWalkDist)(IActorMovementProxy *this, float);
  bool (__fastcall *isOnGround)(IActorMovementProxy *this);
  void (__fastcall *setOnGround)(IActorMovementProxy *this, bool);
  bool (__fastcall *wasOnGround)(IActorMovementProxy *this);
  void (__fastcall *setWasOnGround)(IActorMovementProxy *this, bool);
  int (__fastcall *getHealth)(IActorMovementProxy *this);
  bool (__fastcall *getHorizontalCollision)(IActorMovementProxy *this);
  void (__fastcall *setHorizontalCollision)(IActorMovementProxy *this, bool);
  bool (__fastcall *getVerticalCollision)(IActorMovementProxy *this);
  void (__fastcall *setVerticalCollision)(IActorMovementProxy *this, bool);
  bool (__fastcall *getCollision)(IActorMovementProxy *this);
  void (__fastcall *setCollision)(IActorMovementProxy *this, bool);
  float (__fastcall *getUserDefineMaxAutoStep)(IActorMovementProxy *this);
  float (__fastcall *getMaxAutoStep)(IActorMovementProxy *this);
  bool (__fastcall *isFree)(IActorMovementProxy *this, const Vec3 *);
  float (__fastcall *getHeightOffset)(IActorMovementProxy *this);
  Vec2 *(__fastcall *getSlideOffset)(IActorMovementProxy *this, Vec2 *result);
  void (__fastcall *setSlideOffset)(IActorMovementProxy *this, const Vec2 *);
  void (__fastcall *setTerrainSurfaceOffset)(IActorMovementProxy *this, float);
  const Vec3 *(__fastcall *getBlockMovementSlowdownMultiplier)(IActorMovementProxy *this);
  void (__fastcall *setBlockMovementSlowdownMultiplier)(IActorMovementProxy *this, const Vec3 *);
  float (__fastcall *getCurrentSwimAmount)(IActorMovementProxy *this);
  const WaterMovementComponent *(__fastcall *tryGetWaterMovementComponent)(IActorMovementProxy *this);
  const AttributeInstance *(__fastcall *getAttribute)(IActorMovementProxy *this, const Attribute *);
  bool (__fastcall *hasEffect)(IActorMovementProxy *this, const MobEffect *);
  const MobEffectInstance *(__fastcall *getEffect)(IActorMovementProxy *this, const MobEffect *);
  int (__fastcall *getActiveEffectCount)(IActorMovementProxy *this);
  const SynchedActorData *(__fastcall *getEntityData)(IActorMovementProxy *this);
  void (__fastcall *setStatusFlag)(IActorMovementProxy *this, ActorFlags, bool);
  bool (__fastcall *getStatusFlag)(IActorMovementProxy *this, ActorFlags);
  bool (__fastcall *hasCategory)(IActorMovementProxy *this, ActorCategory);
  bool (__fastcall *isType)(IActorMovementProxy *this, ActorType);
  Vec3 *(__fastcall *getPosition)(IActorMovementProxy *this, Vec3 *result);
  void (__fastcall *setPosition)(IActorMovementProxy *this, const Vec3 *);
  Vec2 *(__fastcall *getRotation)(IActorMovementProxy *this, Vec2 *result);
  void (__fastcall *setRotation)(IActorMovementProxy *this, const Vec2 *);
  const StateVectorComponent *(__fastcall *getStateVectorComponent)(IActorMovementProxy *this);
  StateVectorComponent *(__fastcall *getStateVectorComponentNonConst)(IActorMovementProxy *this);
  const AABBShapeComponent *(__fastcall *getAABBShapeComponent)(IActorMovementProxy *this);
  AABBShapeComponent *(__fastcall *getAABBShapeComponentNonConst)(IActorMovementProxy *this);
  void (__fastcall *setFallDistance)(IActorMovementProxy *this, float);
  bool (__fastcall *isSneaking)(IActorMovementProxy *this);
  void (__fastcall *setSneaking)(IActorMovementProxy *this, bool);
  Vec3 *(__fastcall *getHeadLookVector)(IActorMovementProxy *this, Vec3 *result, float);
  Vec3 *(__fastcall *getViewVector)(IActorMovementProxy *this, Vec3 *result, float);
  const BlockSource *(__fastcall *getRegion)(IActorMovementProxy *this);
  BlockSource *(__fastcall *getRegion)(IActorMovementProxy *this);
  std::vector<AABB> *(__fastcall *fetchCollisionShapes)(IActorMovementProxy *this, const AABB *, float *, bool, IActorMovementProxy *);
  const std::vector<std::shared_ptr<IActorMovementProxy>> *(__fastcall *fetchEntities)(IActorMovementProxy *this, const IActorMovementProxy *, const AABB *);
  bool (__fastcall *hasRegion)(IActorMovementProxy *this);
  IActorMovementProxy *(__fastcall *getRide)(IActorMovementProxy *this);
  bool (__fastcall *isWASDControlled)(IActorMovementProxy *this);
  int (__fastcall *getControllingSeat)(IActorMovementProxy *this);
  int (__fastcall *getRiderIndex)(IActorMovementProxy *this, const IActorMovementProxy *);
  IBoatMovementProxy *(__fastcall *tryAsBoat)(IActorMovementProxy *this);
  IMobMovementProxy *(__fastcall *tryAsMob)(IActorMovementProxy *this);
  IPlayerMovementProxy *(__fastcall *tryAsPlayer)(IActorMovementProxy *this);
  const std::vector<ActorUniqueID> *(__fastcall *getRiderIDs)(IActorMovementProxy *this);
  const ActorUniqueID *(__fastcall *getUniqueID)(IActorMovementProxy *this);
  ActorRuntimeID *(__fastcall *getRuntimeID)(IActorMovementProxy *this, ActorRuntimeID *result);
  AABB *(__fastcall *getHandleWaterAABB)(IActorMovementProxy *this, AABB *result);
  BlockPos *(__fastcall *getBlockPosCurrentlyStandingOn)(IActorMovementProxy *this, BlockPos *result, IActorMovementProxy *);
  void (__fastcall *blockOnStandOn)(IActorMovementProxy *this, const Block *, const BlockPos *);
  bool (__fastcall *_containsSneakCollisionShapes)(IActorMovementProxy *this, const AABB *);
  void (__fastcall *move)(IActorMovementProxy *this, const Vec3 *);
  void (__fastcall *moveBBs)(IActorMovementProxy *this, const Vec3 *);
  void (__fastcall *checkFallDamage)(IActorMovementProxy *this, float, bool);
  void (__fastcall *onBounceStarted)(IActorMovementProxy *this, const BlockPos *, const Block *);
  void (__fastcall *updatePrevPosRot)(IActorMovementProxy *this);
  void (__fastcall *sendActorMove)(IActorMovementProxy *this, const Vec3 *);
  void (__fastcall *_teleportTo)(IActorMovementProxy *this, const Vec3 *, bool, int, int);
  Actor *(__fastcall *_getActor)(IActorMovementProxy *this);
  const Actor *(__fastcall *_getRawActor)(IActorMovementProxy *this);
  Actor *(__fastcall *_getRawActor)(IActorMovementProxy *this);
  SynchedActorData *(__fastcall *_getEntityData)(IActorMovementProxy *this);
  const Vec2 *(__fastcall *_getRotPrev)(IActorMovementProxy *this);
  void (__fastcall *_setRotPrev)(IActorMovementProxy *this, const Vec2 *);
  void (__fastcall *_setPreviousPosRot)(IActorMovementProxy *this, const Vec3 *, const Vec2 *);
  void (__fastcall *_setHasTeleported)(IActorMovementProxy *this, bool);
  gsl::not_null<BaseAttributeMap *> *(__fastcall *_getAttributes)(IActorMovementProxy *this, gsl::not_null<BaseAttributeMap *> *result);
  void (__fastcall *_applySnapshot)(IActorMovementProxy *this, const PlayerSnapshot *);
  std::unique_ptr<PlayerSnapshot> *(__fastcall *_createSnapshot)(IActorMovementProxy *this, std::unique_ptr<PlayerSnapshot> *result);
  AdvanceFrameResult (__fastcall *_advanceLiveFrame)(IActorMovementProxy *this, const IReplayableActorInput *);
};

dragon::rendering::TextureUpdateSlot

struct __cppobj dragon::rendering::TextureUpdateSlot
{
  unsigned __int8 mMip;
  unsigned __int16 mLayer;
  unsigned __int16 mX;
  unsigned __int16 mY;
  unsigned __int16 mWidth;
  unsigned __int16 mHeight;
  unsigned int mPitch;
};

dragon::rendering::TextureResourceType::ResourceUpdateParameters

struct __cppobj dragon::rendering::TextureResourceType::ResourceUpdateParameters
{
  dragon::rendering::TextureUpdateSlot mSlot;
  dragon::memory::BufferSource mUpdateData;
};

dragon::rendering::TextureResourceDescInternal

struct __cppobj __declspec(align(8)) dragon::rendering::TextureResourceDescInternal
{
  std::optional<unsigned __int64> mExternalHandle;
  bool mExternalHandleIsOwned;
};

dragon::rendering::TextureResourceType::ResourceCreationParameters

struct __cppobj dragon::rendering::TextureResourceType::ResourceCreationParameters
{
  cg::TextureDescription mTextureDesc;
  unsigned int mFlags;
  std::optional<unsigned __int64> mExternalHandle;
  bool mExternalHandleIsOwned;
  std::optional<dragon::memory::BufferSource> mInitialData;
};

dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>::BufferResource

struct __cppobj dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>::BufferResource
{
  std::mutex mAccessLock;
  std::vector<dragon::rendering::TextureResourceType::ResourceUpdateParameters> mDeferredOrderedUpdateSequence;
  dragon::rendering::BufferState mState;
  bool mWasEverCreated;
  bool mWasEverUsed;
  bgfx::TextureHandle mResource;
  dragon::rendering::TextureResourceDescInternal mDescription;
  dragon::rendering::TextureResourceDesc mPublicDescription;
  std::optional<dragon::rendering::TextureResourceType::ResourceCreationParameters> mCreationParameters;
};

dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>

struct __cppobj dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>
{
  dragon::rendering::GraphicsTasks *mGraphicsTasks;
  std::atomic<unsigned __int64> mHandleCounter;
  MPMCQueue<std::optional<dragon::rendering::details::BufferHandleTypeWrapper<dragon::rendering::details::TextureHandleTypeKey,unsigned __int64> > > mBuffersDeletionQueue;
  Core::Cache<unsigned __int64,dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>::BufferResource,std::shared_ptr<dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>::BufferResource> > mBuffers;
};

dragon::rendering::TextureResourceManager::Impl

struct __cppobj dragon::rendering::TextureResourceManager::Impl : dragon::rendering::BufferResourceManager<dragon::rendering::TextureResourceType>
{
};

dragon::rendering::TextureResourceManager

struct __cppobj dragon::rendering::TextureResourceManager
{
  std::unique_ptr<dragon::rendering::TextureResourceManager::Impl> mImpl;
  std::optional<dragon::rendering::details::BufferHandleTypeWrapper<dragon::rendering::details::TextureHandleTypeKey,unsigned __int64> > mMissingTexture;
  dragon::rendering::GraphicsTasks *mGraphicsTasks;
};

dragon::platform::ResourcesManager

struct __cppobj dragon::platform::ResourcesManager
{
  dragon::rendering::TextureResourceManager mTextureManager;
  dragon::mesh::VertexDeclManager mVertexDeclManager;
  dragon::mesh::VertexBufferResourceManager mVertexBufferManager;
  dragon::mesh::IndexBufferResourceManager mIndexBufferManager;
  dragon::mesh::VertexSpanRegistry mVertexSpanStorage;
  dragon::mesh::IndexSpanRegistry mIndexSpanStorage;
  dragon::DragonBufferResourceServiceContext mBufferResourceServiceContext;
  dragon::VertexBufferResourceService mVertexBufferResourceService;
  dragon::IndexBufferResourceService mIndexBufferResourceService;
  dragon::ShaderBufferResourceService mShaderBufferResourceService;
  dragon::TextureResourceService mTextureResourceService;
  dragon::AccelerationStructureResourceService mAccelerationStructureResourceService;
};

dragon::rendering::CommandContext

struct __cppobj dragon::rendering::CommandContext
{
  Core::CpuRingBufferAllocator<unsigned char,2,0,Core::CheckedRingBuffer<2,0> > *mAllocator;
  const unsigned __int16 mViewId;
  bgfx::Encoder *const mEncoder;
  dragon::platform::ResourcesManager *mResourcesManager;
  dragon::res::ResolvedTextureResource *mMissingTexture;
  std::vector<dragon::rendering::CommandContext::MaterialTextureBinding> mMaterialTextureBindings;
};

dragon::rendering::BgfxEncoderPool

struct __cppobj __declspec(align(8)) dragon::rendering::BgfxEncoderPool
{
  std::unique_ptr<Bedrock::Threading::InstancedThreadLocal<bgfx::Encoder *,std::allocator<bgfx::Encoder *> >> mThreadEncoder;
  std::thread::id mOwnerId;
};

dragon::memory::BufferSource::UseTracker

struct __cppobj dragon::memory::BufferSource::UseTracker
{
  const std::shared_ptr<std::vector<unsigned char> const > mOwnedMemory;
  const std::weak_ptr<dragon::memory::BufferSource::LifetimeToken> mLifetimePtr;
};

DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>

struct __cppobj DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>
{
  std::shared_ptr<DlcValidationState> dlcState;
  DlcChecker *const __this;
  std::weak_ptr<bool> weakTracker;
  IContentAcquisition *contentAcquisition;
};

DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>::()::__l13::<lambda_d1a8aa78fa8589609cd00c26e91ee09a>

struct __cppobj DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>::()::__l13::<lambda_d1a8aa78fa8589609cd00c26e91ee09a>
{
  std::shared_ptr<DlcValidationState> dlcState;
};

DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>::()::__l8::<lambda_00a0a949d7ce56838b030acefee83b44>

struct __cppobj DlcChecker::check::__l41::<lambda_c5c1e4c1df912d1f0f67141a8d2231de>::()::__l8::<lambda_00a0a949d7ce56838b030acefee83b44>
{
  std::shared_ptr<DlcValidationState> dlcState;
};

DlcValidation

struct __cppobj DlcValidation : IDlcValidation
{
  ContentManager *mContentManager;
  ResourcePackRepository *mResourcePackRepository;
  IEntitlementManager *mEntitlementManager;
  WorldTemplateManager *mWorldTemplateManager;
  gsl::not_null<Bedrock::NonOwnerPointer<StoreCatalogRepository> > mStoreCatalogRepository;
  PackManifestFactory *mPackManifestFactory;
  PackSourceFactory *mPackSourceFactory;
  const IContentKeyProvider *mContentKeyProvider;
};

DlcValidation_vtbl

struct /*VFT*/ DlcValidation_vtbl
{
  void (__fastcall *~IDlcValidation)(IDlcValidation *this);
  std::vector<DlcDependency> *(__fastcall *collectDlcDependenciesForWorld)(IDlcValidation *this, std::vector<DlcDependency> *result, const std::string *, const PackIdVersion *, bool);
  bool (__fastcall *getNextUnownedDlcDependency)(IDlcValidation *this, const std::vector<DlcDependency> *, DlcDependency *);
  std::vector<DlcDependency> *(__fastcall *getMissingOwnedDlcDependencies)(IDlcValidation *this, std::vector<DlcDependency> *result, const std::vector<DlcDependency> *);
  bool (__fastcall *hasUnownedDlcDependencies)(IDlcValidation *this, const std::vector<DlcDependency> *);
  bool (__fastcall *hasOwnedMissingDlcDependencies)(IDlcValidation *this, const std::vector<DlcDependency> *);
  DlcDependency *(__fastcall *getMissingOwnedDlcWorldTemplateDependency)(IDlcValidation *this, DlcDependency *result, const std::vector<DlcDependency> *, bool);
  bool (__fastcall *hasOwnedMissingDlcWorldTemplateDependency)(IDlcValidation *this, const std::vector<DlcDependency> *, bool);
  bool (__fastcall *hasPerformanceIssues)(IDlcValidation *this, const std::vector<DlcId> *);
  bool (__fastcall *hasEntitlementFor)(IDlcValidation *this, const ContentIdentity *);
  PackManifestFactory *(__fastcall *getPackManifestFactory)(IDlcValidation *this);
  PackSourceFactory *(__fastcall *getPackSourceFactory)(IDlcValidation *this);
  const IContentKeyProvider *(__fastcall *getKeyProvider)(IDlcValidation *this);
};

DLGTEMPLATE

struct __unaligned __declspec(align(2)) DLGTEMPLATE
{
  unsigned int style;
  unsigned int dwExtendedStyle;
  unsigned __int16 cdit;
  __int16 x;
  __int16 y;
  __int16 cx;
  __int16 cy;
};

DISPLAYCONFIG_DEVICE_INFO_HEADER

struct DISPLAYCONFIG_DEVICE_INFO_HEADER
{
  DISPLAYCONFIG_DEVICE_INFO_TYPE type;
  unsigned int size;
  _LUID adapterId;
  unsigned int id;
};

DISPLAYCONFIG_RATIONAL

struct DISPLAYCONFIG_RATIONAL
{
  unsigned int Numerator;
  unsigned int Denominator;
};

DISPLAYCONFIG_DESKTOP_IMAGE_INFO

struct DISPLAYCONFIG_DESKTOP_IMAGE_INFO
{
  _POINTL PathSourceSize;
  _RECTL DesktopImageRegion;
  _RECTL DesktopImageClip;
};

DLGITEMTEMPLATE

struct __unaligned __declspec(align(2)) DLGITEMTEMPLATE
{
  unsigned int style;
  unsigned int dwExtendedStyle;
  __int16 x;
  __int16 y;
  __int16 cx;
  __int16 cy;
  unsigned __int16 id;
};

DISPLAYCONFIG_SOURCE_MODE

struct DISPLAYCONFIG_SOURCE_MODE
{
  unsigned int width;
  unsigned int height;
  DISPLAYCONFIG_PIXELFORMAT pixelFormat;
  _POINTL position;
};

DPI_AWARENESS_CONTEXT__

struct DPI_AWARENESS_CONTEXT__
{
  int unused;
};

DISPLAYCONFIG_ADAPTER_NAME

struct DISPLAYCONFIG_ADAPTER_NAME
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  wchar_t adapterDevicePath[128];
};

DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS

struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
{
  $A0DA7080AE0E713552687695E6F945A2 ___u0;
};

DISPLAYCONFIG_TARGET_DEVICE_NAME

struct DISPLAYCONFIG_TARGET_DEVICE_NAME
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
  DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
  unsigned __int16 edidManufactureId;
  unsigned __int16 edidProductCodeId;
  unsigned int connectorInstance;
  wchar_t monitorFriendlyDeviceName[64];
  wchar_t monitorDevicePath[128];
};

DISPLAYCONFIG_TARGET_BASE_TYPE

struct DISPLAYCONFIG_TARGET_BASE_TYPE
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY baseOutputTechnology;
};

debug_assert::set_level<0>

struct __cppobj debug_assert::set_level<0>
{
};

debug_assert::default_handler

struct __cppobj debug_assert::default_handler
{
};

debug_assert::set_level<1>

struct __cppobj debug_assert::set_level<1>
{
};

Detail::HashHelper<gsl::basic_string_span<char const ,-1> >

struct __cppobj Detail::HashHelper<gsl::basic_string_span<char const ,-1> >
{
};

Detail::HashHelper<wchar_t const *>

struct __cppobj Detail::HashHelper<wchar_t const *>
{
};

Detail::HashHelper64<char const *>

struct __cppobj Detail::HashHelper64<char const *>
{
};

Detail::HashHelper64<std::string >

struct __cppobj Detail::HashHelper64<std::string >
{
};

Detail::HashHelper<char const *>

struct __cppobj Detail::HashHelper<char const *>
{
};

Detail::HashHelper<std::wstring >

struct __cppobj Detail::HashHelper<std::wstring >
{
};

Detail::HashHelper<std::string >

struct __cppobj Detail::HashHelper<std::string >
{
};

DISPLAYCONFIG_2DREGION

struct DISPLAYCONFIG_2DREGION
{
  unsigned int cx;
  unsigned int cy;
};

DISPLAYCONFIG_VIDEO_SIGNAL_INFO::<anonymous-tag>::<unnamed_type_AdditionalSignalInfo>

struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO::<anonymous-tag>::<unnamed_type_AdditionalSignalInfo>
{
  unsigned __int32 videoStandard : 16;
  unsigned __int32 vSyncFreqDivider : 6;
  unsigned __int32 reserved : 10;
};

DISPLAYCONFIG_VIDEO_SIGNAL_INFO

struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
{
  unsigned __int64 pixelRate;
  DISPLAYCONFIG_RATIONAL hSyncFreq;
  DISPLAYCONFIG_RATIONAL vSyncFreq;
  DISPLAYCONFIG_2DREGION activeSize;
  DISPLAYCONFIG_2DREGION totalSize;
  $75E4346473E4536034183FB929BACA6C ___u5;
  DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
};

DISPLAYCONFIG_TARGET_MODE

struct DISPLAYCONFIG_TARGET_MODE
{
  DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
};

DISPLAYCONFIG_SUPPORT_VIRTUAL_RESOLUTION

struct DISPLAYCONFIG_SUPPORT_VIRTUAL_RESOLUTION
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  $3C6B816D6CC58F7A4CEFDEAD0460C7B8 ___u1;
};

debug_assert::source_location

struct __declspec(align(8)) debug_assert::source_location
{
  const char *file_name;
  unsigned int line_number;
};

debug_assert::allow_exception

struct __cppobj debug_assert::allow_exception
{
};

debug_assert::no_handler

struct __cppobj debug_assert::no_handler
{
};

debug_assert::detail::remove_reference<char const (&)[27]>

struct __cppobj debug_assert::detail::remove_reference<char const (&)[27]>
{
};

debug_assert::detail::remove_reference<char const (&)[37]>

struct __cppobj debug_assert::detail::remove_reference<char const (&)[37]>
{
};

debug_assert::detail::remove_reference<char const (&)[33]>

struct __cppobj debug_assert::detail::remove_reference<char const (&)[33]>
{
};

debug_assert::detail::remove_reference<char const (&)[58]>

struct __cppobj debug_assert::detail::remove_reference<char const (&)[58]>
{
};

debug_assert::detail::allows_exception<type_safe::detail::on_disabled_exception'::2'::handler,void>

struct __cppobj debug_assert::detail::allows_exception<`type_safe::detail::on_disabled_exception'::`2'::handler,void>
{
};

debug_assert::detail::regular_void

struct __cppobj debug_assert::detail::regular_void
{
};

debug_assert::detail::enable_if<1,debug_assert::detail::regular_void>

struct __cppobj debug_assert::detail::enable_if<1,debug_assert::detail::regular_void>
{
};

debug_assert::detail::allows_exception<type_safe::detail::precondition_error_handler,void>

struct __cppobj debug_assert::detail::allows_exception<type_safe::detail::precondition_error_handler,void>
{
};

debug_assert::detail::remove_reference<char const (&)[26]>

struct __cppobj debug_assert::detail::remove_reference<char const (&)[26]>
{
};

debug_assert::detail::enable_if<0,debug_assert::detail::regular_void>

struct __cppobj debug_assert::detail::enable_if<0,debug_assert::detail::regular_void>
{
};

DISPLAYCONFIG_SET_TARGET_PERSISTENCE

struct DISPLAYCONFIG_SET_TARGET_PERSISTENCE
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  $E34C787AB30A5AC1281FC932E474A963 ___u1;
};

DISPLAYCONFIG_MODE_INFO

struct DISPLAYCONFIG_MODE_INFO
{
  DISPLAYCONFIG_MODE_INFO_TYPE infoType;
  unsigned int id;
  _LUID adapterId;
  $BFAB74A24D210222DDFA912A0A84DE31 ___u3;
};

DISPLAYCONFIG_PATH_SOURCE_INFO

struct DISPLAYCONFIG_PATH_SOURCE_INFO
{
  _LUID adapterId;
  unsigned int id;
  $84EE8BE871171EA71FDE0DCA277E9276 ___u2;
  unsigned int statusFlags;
};

DISPLAYCONFIG_PATH_TARGET_INFO

struct DISPLAYCONFIG_PATH_TARGET_INFO
{
  _LUID adapterId;
  unsigned int id;
  $8469372A6DBC14B4A5C2479CADAEB873 ___u2;
  DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
  DISPLAYCONFIG_ROTATION rotation;
  DISPLAYCONFIG_SCALING scaling;
  DISPLAYCONFIG_RATIONAL refreshRate;
  DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
  int targetAvailable;
  unsigned int statusFlags;
};

DISPLAYCONFIG_PATH_INFO

struct DISPLAYCONFIG_PATH_INFO
{
  DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
  DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
  unsigned int flags;
};

DISPLAYCONFIG_SOURCE_DEVICE_NAME

struct DISPLAYCONFIG_SOURCE_DEVICE_NAME
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  wchar_t viewGdiDeviceName[32];
};

DISPLAYCONFIG_TARGET_PREFERRED_MODE

struct DISPLAYCONFIG_TARGET_PREFERRED_MODE
{
  DISPLAYCONFIG_DEVICE_INFO_HEADER header;
  unsigned int width;
  unsigned int height;
  DISPLAYCONFIG_TARGET_MODE targetMode;
};

DISK_SPACE_INFORMATION

struct DISK_SPACE_INFORMATION
{
  unsigned __int64 ActualTotalAllocationUnits;
  unsigned __int64 ActualAvailableAllocationUnits;
  unsigned __int64 ActualPoolUnavailableAllocationUnits;
  unsigned __int64 CallerTotalAllocationUnits;
  unsigned __int64 CallerAvailableAllocationUnits;
  unsigned __int64 CallerPoolUnavailableAllocationUnits;
  unsigned __int64 UsedAllocationUnits;
  unsigned __int64 TotalReservedAllocationUnits;
  unsigned __int64 VolumeStorageReserveAllocationUnits;
  unsigned __int64 AvailableCommittedAllocationUnits;
  unsigned __int64 PoolAvailableAllocationUnits;
  unsigned int SectorsPerAllocationUnit;
  unsigned int BytesPerSector;
};

DistanceActivationRule

struct __cppobj __declspec(align(8)) DistanceActivationRule : ActivationRule
{
  float mDistanceSquared;
};

DistanceActivationRule_vtbl

struct /*VFT*/ DistanceActivationRule_vtbl
{
  void (__fastcall *~ActivationRule)(ActivationRule *this);
  std::unique_ptr<ActivationRule> *(__fastcall *create)(ActivationRule *this, std::unique_ptr<ActivationRule> *result, Json::Value *);
  bool (__fastcall *evaluate)(ActivationRule *this, const IClientInstance *, float, const Camera *);
};

DataUtils::MiscData

struct __cppobj __declspec(align(4)) DataUtils::MiscData : Bedrock::EnableNonOwnerReferences
{
  DataUtils::MiscData_vtbl *__vftable /*VFT*/;
  std::unordered_map<std::string,bool> mShields;
  std::set<int> mItemClientEventUserDataWhiteList;
  std::set<int> mItemServerEventUserDataWhiteList;
  std::set<HashedString> mActorTickServerEventWhiteList;
  bool mShowHealth;
  bool mStoreEntranceVisible;
  bool mStoreEntranceShutDown;
  bool mDeepTest;
  bool mF11Touch;
  std::tuple<float,float> mInputVector;
  bool mIsRenderLocalPlayer;
  bool mIsHideGUI;
  bool mHidePersionGUI;
  bool mHideWalkGUI;
  bool mHideJumpGUI;
  bool mHideSlotBar;
  bool mHideFlodMenu;
  bool mHideSwimUpGUI;
  bool mHideSwimDownGUI;
  bool mHideHealthGUI;
  bool mHideHungerGUI;
  bool mHideExpGUI;
  bool mHideArmorGUI;
  bool mHideHorseHealthGUI;
  bool mHideAirSupplyGUI;
  bool mIsCustomMove;
  bool mCustomSprinting;
  std::string mCustomDirection;
  bool mCustomMoveBool;
  bool mIsHideHudGui;
  bool mMoveInput;
  std::string mDefaultFont;
  bool mVoiceTransVisible;
  unsigned int mUiBatchOptBit;
  int mTouchingId;
  int mSwallowTouchMode;
  bool mShowReportButton;
  bool mMobileAuthenticated;
  int mMobileAuthenticateState;
  int mCtrlMode;
  int mHoldTimeThresholdInMs;
  float mJsonSpeedTime;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStartLaunchGameTime;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStopLaunchGameTime;
  bool mValidActorAnimation;
  bool mUseRapidJson;
  bool mStrictLevelChunkTagKey;
  bool mBlockRefreshWhenBtnUpClick;
  bool mInitUIAsyncLoadingAndAnimations;
  bool mBlockSelectSlot;
  int mMergeSpawnItemRadius;
  bool mRemoveColorCodesWhenFilterWords;
};

DataUtils::MiscData_vtbl

struct /*VFT*/ DataUtils::MiscData_vtbl
{
  void (__fastcall *~MiscData)(DataUtils::MiscData *this);
};

DataBackedAppConfigs::Data

struct __cppobj DataBackedAppConfigs::Data
{
  bool mAllowResourcePacks;
  bool mAllowPlayScreen;
  bool mAllowChatScreen;
  bool mQuizzesSupported;
  bool mLessonProgressionSupported;
  bool mNormalizedFontSize;
  bool mFullscreenDefault;
  bool mMuteDefault;
  bool mCourseCacheEnabled;
  bool mPromptBeforeExit;
  bool mGameArgumentsNeedAuthentication;
  bool mWorldBuilderDisabled;
  bool mWebSocketsDisabled;
  bool mWorldsAreSingleUse;
  bool mRequireTrustedContent;
  bool mSendPermissionsTelemetry;
  _BYTE mOffer[4];
  std::unique_ptr<ConnectionDefinition> mConnectionDefinition;
  bool mChangeMultiplayerDuringPlay;
  std::unique_ptr<std::vector<PackIdVersion>> mAdditionalClientPacks;
  std::unique_ptr<ByValueLevelDataOverride> mLevelData;
  std::string mFeedbackURL;
};

DataBackedAppConfigs

struct __cppobj DataBackedAppConfigs : AppConfigs
{
  DataBackedAppConfigs::Data mData;
};

DataBackedAppConfigs_vtbl

struct /*VFT*/ DataBackedAppConfigs_vtbl
{
  void (__fastcall *~AppConfigs)(AppConfigs *this);
  void (__fastcall *loadFromData)(AppConfigs *this, const IAppConfigData *);
  bool (__fastcall *areResourcePacksAllowed)(AppConfigs *this);
  bool (__fastcall *isPlayScreenAllowed)(AppConfigs *this);
  bool (__fastcall *isChatScreenAllowed)(AppConfigs *this);
  bool (__fastcall *isGameTabShownInSettings)(AppConfigs *this);
  bool (__fastcall *areQuizzesSupported)(AppConfigs *this);
  bool (__fastcall *isLessonProgressionSupported)(AppConfigs *this);
  bool (__fastcall *useNormalizedFontSize)(AppConfigs *this);
  bool (__fastcall *useFullScreenByDefault)(AppConfigs *this);
  bool (__fastcall *muteByDefault)(AppConfigs *this);
  bool (__fastcall *isCoursesCacheEnabled)(AppConfigs *this);
  bool (__fastcall *shouldPromptBeforeExit)(AppConfigs *this);
  bool (__fastcall *gameArgumentsNeedAuthentication)(AppConfigs *this);
  bool (__fastcall *worldBuilderDisabled)(AppConfigs *this);
  bool (__fastcall *worldsAreSingleUse)(AppConfigs *this);
  EducationEditionOffer (__fastcall *getEducationEditionOffering)(AppConfigs *this);
  bool (__fastcall *requireTrustedContent)(AppConfigs *this);
  ConnectionDefinition *(__fastcall *getConnectionDefinition)(AppConfigs *this, ConnectionDefinition *result);
  bool (__fastcall *supportsChangingMultiplayerDuringPlay)(AppConfigs *this);
  bool (__fastcall *webSocketsDisabled)(AppConfigs *this);
  bool (__fastcall *sendPermissionsTelemetry)(AppConfigs *this);
  void (__fastcall *setCanAccessWorldCallback)(AppConfigs *this, IMinecraftGame *);
  std::vector<PackIdVersion> *(__fastcall *getAdditionalClientPacks)(AppConfigs *this, std::vector<PackIdVersion> *result, bool);
  std::unique_ptr<IScreenCapabilities> *(__fastcall *getScreenCapabilities)(AppConfigs *this, std::unique_ptr<IScreenCapabilities> *result, const std::string *);
  std::unique_ptr<IContentAccessibilityProvider> *(__fastcall *createContentAccessibility)(AppConfigs *this, std::unique_ptr<IContentAccessibilityProvider> *result, IEntitlementManager *);
  std::string *(__fastcall *getFeedbackURL)(AppConfigs *this, std::string *result);
  void (__fastcall *applyLevelDataOverride)(AppConfigs *this, LevelData *);
};

DebugInfoMessageType::<lambda_74400b49f2c4907652656c8d21c03c03>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_74400b49f2c4907652656c8d21c03c03>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_74400b49f2c4907652656c8d21c03c03>

struct __cppobj DebugInfoMessageType::<lambda_74400b49f2c4907652656c8d21c03c03>
{
};

DebugInfoMessageType::<lambda_872cd9e784ad00a9e06eae33e3ffd707>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_872cd9e784ad00a9e06eae33e3ffd707>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_872cd9e784ad00a9e06eae33e3ffd707>

struct __cppobj DebugInfoMessageType::<lambda_872cd9e784ad00a9e06eae33e3ffd707>
{
};

DebugInfoMessageType::<lambda_98dd7f4d0672cbd3afd4ef2bab49d795>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_98dd7f4d0672cbd3afd4ef2bab49d795>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_98dd7f4d0672cbd3afd4ef2bab49d795>

struct __cppobj DebugInfoMessageType::<lambda_98dd7f4d0672cbd3afd4ef2bab49d795>
{
};

DebugInfoMessageType::<lambda_6b192fb09c03525f9798cc3d5754b9ca>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_6b192fb09c03525f9798cc3d5754b9ca>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_6b192fb09c03525f9798cc3d5754b9ca>

struct __cppobj DebugInfoMessageType::<lambda_6b192fb09c03525f9798cc3d5754b9ca>
{
};

DebugInfoMessageType::<lambda_973afee8942f37319f9efc132e8f57a5>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_973afee8942f37319f9efc132e8f57a5>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_973afee8942f37319f9efc132e8f57a5>

struct __cppobj DebugInfoMessageType::<lambda_973afee8942f37319f9efc132e8f57a5>
{
};

DebugInfoMessageType::<lambda_069335932217d365dd9d11c1ffe8f6dc>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_069335932217d365dd9d11c1ffe8f6dc>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_069335932217d365dd9d11c1ffe8f6dc>

struct __cppobj DebugInfoMessageType::<lambda_069335932217d365dd9d11c1ffe8f6dc>
{
};

DebugInfoMessageType::<lambda_704b857e804d3263b940dc11c4dde273>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_704b857e804d3263b940dc11c4dde273>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_704b857e804d3263b940dc11c4dde273>

struct __cppobj DebugInfoMessageType::<lambda_704b857e804d3263b940dc11c4dde273>
{
};

DebugInfoMessageType::<lambda_d7da6cf275d6fa6f0ad3e89d3cb4e42f>::()::__l2::Literal

struct __cppobj DebugInfoMessageType::<lambda_d7da6cf275d6fa6f0ad3e89d3cb4e42f>::()::__l2::Literal
{
};

DebugInfoMessageType::<lambda_d7da6cf275d6fa6f0ad3e89d3cb4e42f>

struct __cppobj DebugInfoMessageType::<lambda_d7da6cf275d6fa6f0ad3e89d3cb4e42f>
{
};

dragon::materials::definition::StageInputDefinition

struct __cppobj dragon::materials::definition::StageInputDefinition
{
  std::unordered_map<enum dragon::materials::definition::ShaderStage,std::unordered_map<std::string,dragon::materials::definition::ShaderInput>> mInputs;
};

dragon::materials::definition::BlendModeHasher

struct __cppobj dragon::materials::definition::BlendModeHasher
{
};

dragon::materials::definition::FlagDefinition

struct __cppobj dragon::materials::definition::FlagDefinition
{
  std::vector<std::string> mPossibleValues;
};

dragon::materials::definition::DebugSourceLocation

struct __cppobj dragon::materials::definition::DebugSourceLocation
{
  std::string mPath;
  unsigned __int64 mLine;
};

dragon::materials::definition::OptionValues

struct __cppobj dragon::materials::definition::OptionValues
{
  bool mIsCustom;
  dragon::materials::definition::DebugSourceLocation mDebugLocation;
  std::unordered_set<std::string> mValues;
};

dragon::materials::definition::MaterialPassDeclaration

struct __cppobj __declspec(align(8)) dragon::materials::definition::MaterialPassDeclaration
{
  dragon::materials::definition::GraphicsProfile mGraphicsProfile;
  std::string mFallback;
  std::unordered_map<std::string,dragon::materials::definition::FlagDefinition> mFlags;
  std::vector<std::vector<dragon::materials::definition::FlagMode>> mInvalidFlagCombinations;
  std::unordered_map<std::string,dragon::materials::definition::OptionValues> mOptions;
  std::bitset<16> mActiveRenderTargets;
};

dragon::materials::definition::PropertyFieldSimpleName<glm::tvec4<float,0> >

struct __cppobj dragon::materials::definition::PropertyFieldSimpleName<glm::tvec4<float,0> >
{
};

dragon::materials::definition::PropertyFieldSimpleName<float>

struct __cppobj dragon::materials::definition::PropertyFieldSimpleName<float>
{
};

dragon::materials::definition::PropertyFieldSimpleName<glm::tmat3x3<float,0> >

struct __cppobj dragon::materials::definition::PropertyFieldSimpleName<glm::tmat3x3<float,0> >
{
};

dragon::materials::definition::PropertyFieldSimpleName<glm::tmat4x4<float,0> >

struct __cppobj dragon::materials::definition::PropertyFieldSimpleName<glm::tmat4x4<float,0> >
{
};

dragon::materials::definition::SharedCodeSection

struct __cppobj dragon::materials::definition::SharedCodeSection
{
  std::string mCode;
  dragon::materials::definition::DebugSourceLocation mDebugLocation;
};

dragon::materials::definition::ShaderContent

struct __cppobj dragon::materials::definition::ShaderContent
{
  std::vector<dragon::materials::definition::SharedCodeSection> mPrefixSharedCode;
  std::vector<dragon::materials::definition::SharedCodeSection> mPrefixPassCode;
  std::vector<dragon::materials::definition::SharedCodeSection> mPostfixPassCode;
  _BYTE mType[4];
  std::string mReferencePass;
  std::string mCode;
  dragon::materials::definition::StageInputDefinition mStageInputDefinition;
  dragon::materials::definition::DebugSourceLocation mDebugLocation;
};

dragon::materials::definition::MaterialPass

struct __cppobj dragon::materials::definition::MaterialPass
{
  dragon::materials::definition::ShaderContent mShader;
  dragon::materials::definition::MaterialPassDeclaration mDeclarations;
};

dragon::materials::definition::MaterialUsedPass

struct __cppobj dragon::materials::definition::MaterialUsedPass
{
  std::string mMaterialName;
};

dragon::PanicAndUnwind

struct __cppobj dragon::PanicAndUnwind
{
  std::string_view mMessage;
};

dragon::materials::MaterialUniform::TextureParameter

struct __cppobj __declspec(align(4)) dragon::materials::MaterialUniform::TextureParameter
{
  const dragon::materials::MaterialUniform *mParameter;
  unsigned __int8 mTextureSlot;
  dragon::materials::definition::SamplerType mType;
  std::variant<dragon::res::ResolvedTextureResource *,dragon::materials::MaterialUniformName> mTexture;
  unsigned int mSamplerFlags;
  dragon::materials::TextureBindType mBindType;
  dragon::materials::definition::SamplerAccess mAccess;
};

dragon::materials::MaterialUniform::BufferParameter

struct __cppobj __declspec(align(8)) dragon::materials::MaterialUniform::BufferParameter
{
  const dragon::materials::MaterialUniform *mParameter;
  unsigned __int8 mSlot;
  std::variant<std::optional<unsigned short>,std::optional<dragon::rendering::details::BufferHandleTypeWrapper<dragon::mesh::details::VertexBufferHandleTypeKey,unsigned __int64> >,std::optional<dragon::rendering::details::BufferHandleTypeWrapper<dragon::mesh::details::IndexBufferHandleTypeKey,unsigned __int64> > > mBuffer;
  dragon::materials::definition::SamplerAccess mAccess;
};

dragon::materials::details::materialentry::EntryCreator<int,dragon::materials::MaterialUniform::TextureParameter>

struct __cppobj dragon::materials::details::materialentry::EntryCreator<int,dragon::materials::MaterialUniform::TextureParameter>
{
};

DuplicateKey

struct DuplicateKey
{
  int index;
  int key;
};

DayOneExperienceGuidedFlow

struct __cppobj DayOneExperienceGuidedFlow : GuidedFlow
{
};

DayOneExperienceGuidedFlow_vtbl

struct /*VFT*/ DayOneExperienceGuidedFlow_vtbl
{
  void (__fastcall *~GuidedFlow)(GuidedFlow *this);
  void (__fastcall *initialize)(GuidedFlow *this, const IGuidedFlowClient *);
  void (__fastcall *finish)(GuidedFlow *this, const IGuidedFlowClient *, const bool);
};

DebugInfoListenerHandle

struct __cppobj DebugInfoListenerHandle
{
  int mListenerId;
};

DebugInfoMessageDispatcher::Listener

struct __cppobj DebugInfoMessageDispatcher::Listener
{
  int listenerId;
  HashedString messageType;
  ActorUniqueID actorId;
  std::function<void __cdecl(Json::Value const &)> callback;
};

DebugInfoMessageDispatcher

struct __cppobj DebugInfoMessageDispatcher
{
  std::vector<DebugInfoMessageDispatcher::Listener> mListeners;
  PacketSender *mPacketSender;
};

DebugInfoPacketHandler

struct __cppobj DebugInfoPacketHandler
{
  std::unique_ptr<DebugInfoMessageDispatcher> mDebugInfoMessageDispatcher;
};

DamageableItemComponent

struct __cppobj __declspec(align(8)) DamageableItemComponent : ItemComponent
{
  int mMaxDamage;
  IntRange mDamageChance;
};

DamageableItemComponent_vtbl

struct /*VFT*/ DamageableItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

DiggerItemComponent::BlockInfo

struct __cppobj __declspec(align(8)) DiggerItemComponent::BlockInfo
{
  BlockDescriptor filter;
  DefinitionTrigger onDig;
  int destroySpeed;
};

DiggerItemComponent

struct __cppobj DiggerItemComponent : ItemComponent
{
  bool mUseEfficiency;
  std::vector<DiggerItemComponent::BlockInfo> mDestroySpeeds;
  DefinitionTrigger mOnDigDefault;
};

DiggerItemComponent_vtbl

struct /*VFT*/ DiggerItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

DescriptionIdSetter

struct __cppobj DescriptionIdSetter
{
  ComponentItem *mOwner;
};

DisplayNameItemComponent

struct __cppobj DisplayNameItemComponent : ItemComponent
{
  DescriptionIdSetter descriptionIdSetter;
};

DisplayNameItemComponent_vtbl

struct /*VFT*/ DisplayNameItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

DyeableComponent

struct __cppobj DyeableComponent : ItemComponent
{
  mce::Color mDefaultColor;
};

DyeableComponent_vtbl

struct /*VFT*/ DyeableComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

DyePowderItemComponent

struct __cppobj __declspec(align(8)) DyePowderItemComponent : ItemComponent
{
  _BYTE mColor[1];
};

DyePowderItemComponent_vtbl

struct /*VFT*/ DyePowderItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

DirectoryEntry

struct DirectoryEntry
{
  int dir_id;
  unsigned int offset;
  unsigned int count;
};

DateManagerOptions

struct __cppobj DateManagerOptions
{
};

Detail::HashHelper<char [12]>

struct __cppobj Detail::HashHelper<char [12]>
{
};

Detail::HashHelper<char [16]>

struct __cppobj Detail::HashHelper<char [16]>
{
};

Detail::HashHelper<char [7]>

struct __cppobj Detail::HashHelper<char [7]>
{
};

DebugComponent

struct __cppobj DebugComponent : UIComponent
{
  std::string mDescription;
};

DebugComponent_vtbl

struct /*VFT*/ DebugComponent_vtbl
{
  void (__fastcall *~UIComponent)(UIComponent *this);
  void (__fastcall *OnScreenPop)(UIComponent *this);
  std::unique_ptr<UIComponent> *(__fastcall *clone)(UIComponent *this, std::unique_ptr<UIComponent> *result, UIControl *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, const ScreenEvent *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, VisualTree *, ScreenInputContext *, UIAnimationController *, const ScreenEvent *);
  void (__fastcall *onNotifyChildAdded)(UIComponent *this);
  void (__fastcall *onNotifyChildRemoved)(UIComponent *this);
  void (__fastcall *onRemoved)(UIComponent *this);
  void (__fastcall *onAdded)(UIComponent *this);
  void (__fastcall *onVisibilityChanged)(UIComponent *this, bool);
  void (__fastcall *onEnabledChanged)(UIComponent *this, bool);
  bool (__fastcall *isRenderableComponent)(UIComponent *this);
  bool (__fastcall *onLayoutChange)(UIComponent *this);
  void (__fastcall *reset)(UIComponent *this);
  void (__fastcall *reload)(UIComponent *this, const UIComponent *);
  const std::string *(__fastcall *getTextToSpeechComponentValue)(UIComponent *this);
};

DataBindingComponent::_updateCollectionBindingIndicies::__l2::<lambda_c017aff85aed3cc652590446c7ac10e1>::()::__l21::<lambda_7d84dac702c1f2486c817ccbb9c53dd9>

struct __cppobj DataBindingComponent::_updateCollectionBindingIndicies::__l2::<lambda_c017aff85aed3cc652590446c7ac10e1>::()::__l21::<lambda_7d84dac702c1f2486c817ccbb9c53dd9>
{
  Json::Value *collectionArray;
  std::string *prefix;
};

DataBindingComponent::_bind::__l33::<lambda_1263d730a78e337456525ffb9b5c50cf>

struct __cppobj DataBindingComponent::_bind::__l33::<lambda_1263d730a78e337456525ffb9b5c50cf>
{
  DataBindingComponent *const __this;
};

DropdownComponent

struct __cppobj DropdownComponent : UIComponent
{
  unsigned int mDropdownNameId;
  std::weak_ptr<UIControl> mContentControl;
  std::weak_ptr<UIControl> mAreaControl;
};

DropdownComponent_vtbl

struct /*VFT*/ DropdownComponent_vtbl
{
  void (__fastcall *~UIComponent)(UIComponent *this);
  void (__fastcall *OnScreenPop)(UIComponent *this);
  std::unique_ptr<UIComponent> *(__fastcall *clone)(UIComponent *this, std::unique_ptr<UIComponent> *result, UIControl *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, const ScreenEvent *);
  ComponentReceiveActionType (__fastcall *receive)(UIComponent *this, VisualTree *, ScreenInputContext *, UIAnimationController *, const ScreenEvent *);
  void (__fastcall *onNotifyChildAdded)(UIComponent *this);
  void (__fastcall *onNotifyChildRemoved)(UIComponent *this);
  void (__fastcall *onRemoved)(UIComponent *this);
  void (__fastcall *onAdded)(UIComponent *this);
  void (__fastcall *onVisibilityChanged)(UIComponent *this, bool);
  void (__fastcall *onEnabledChanged)(UIComponent *this, bool);
  bool (__fastcall *isRenderableComponent)(UIComponent *this);
  bool (__fastcall *onLayoutChange)(UIComponent *this);
  void (__fastcall *reset)(UIComponent *this);
  void (__fastcall *reload)(UIComponent *this, const UIComponent *);
  const std::string *(__fastcall *getTextToSpeechComponentValue)(UIComponent *this);
};

DebugScreenRenderer

struct __cppobj DebugScreenRenderer : MinecraftUICustomRenderer
{
};

DebugScreenRenderer_vtbl

struct /*VFT*/ DebugScreenRenderer_vtbl
{
  void (__fastcall *~UICustomRenderer)(UICustomRenderer *this);
  void (__fastcall *preRenderSetup)(UICustomRenderer *this, UIRenderContext *);
  std::shared_ptr<UICustomRenderer> *(__fastcall *clone)(UICustomRenderer *this, std::shared_ptr<UICustomRenderer> *result);
  bool (__fastcall *update)(UICustomRenderer *this, IClientInstance *, UIControl *, const UIScene *);
  void (__fastcall *frameUpdate)(UICustomRenderer *this, UIFrameUpdateContext *, UIControl *);
  void (__fastcall *render)(UICustomRenderer *this, UIRenderContext *, IClientInstance *, UIControl *, int, RectangleArea *);
  UIBatchType (__fastcall *getBatchType)(UICustomRenderer *this);
  int (__fastcall *getCustomId)(UICustomRenderer *this);
  int (__fastcall *getNumRenderPasses)(UICustomRenderer *this);
  ResourceLocation *(__fastcall *getResourceLocation)(UICustomRenderer *this, ResourceLocation *result, int, int);
  UIMaterialType (__fastcall *getUIMaterialType)(UICustomRenderer *this, int);
  bool (__fastcall *getRequiresPreRenderSetup)(UICustomRenderer *this, int);
  void (__fastcall *onVisibilityChanged)(UICustomRenderer *this, bool);
  void (__fastcall *collectScreenEvents)(UICustomRenderer *this, std::queue<ScreenEvent> *);
  void (__fastcall *frameUpdate)(MinecraftUICustomRenderer *this, MinecraftUIFrameUpdateContext *, UIControl *);
  void (__fastcall *render)(MinecraftUICustomRenderer *this, MinecraftUIRenderContext *, IClientInstance *, UIControl *, int, RectangleArea *);
  void (__fastcall *preRenderSetup)(MinecraftUICustomRenderer *this, MinecraftUIRenderContext *);
};

DebugUIRenderer

struct __cppobj DebugUIRenderer
{
};

DeferredTextObject

struct __cppobj __declspec(align(8)) DeferredTextObject
{
  std::function<void __cdecl(void)> mParseRawInputCallback;
  std::string mRawText;
  bool mRawTextModfied;
};

DimensionChangeProgressHandler

struct __cppobj DimensionChangeProgressHandler : WorldGenerationProgressHandler
{
};

DimensionChangeProgressHandler_vtbl

struct /*VFT*/ DimensionChangeProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

Detail::HashHelper<char [13]>

struct __cppobj Detail::HashHelper<char [13]>
{
};

Detail::HashHelper<char [31]>

struct __cppobj Detail::HashHelper<char [31]>
{
};

Detail::HashHelper<char [32]>

struct __cppobj Detail::HashHelper<char [32]>
{
};

Detail::HashHelper<char [8]>

struct __cppobj Detail::HashHelper<char [8]>
{
};

Detail::HashHelper<char [44]>

struct __cppobj Detail::HashHelper<char [44]>
{
};

Detail::HashHelper<char [34]>

struct __cppobj Detail::HashHelper<char [34]>
{
};

Detail::HashHelper<char [41]>

struct __cppobj Detail::HashHelper<char [41]>
{
};

Detail::HashHelper<char [43]>

struct __cppobj Detail::HashHelper<char [43]>
{
};

DayOneExperienceIntroScreenController

struct __cppobj __declspec(align(8)) DayOneExperienceIntroScreenController : MainMenuScreenController
{
  DayOneExperienceIntroScreenTabs mActiveTabIndex;
};

DayOneExperienceIntroScreenController_vtbl

struct /*VFT*/ DayOneExperienceIntroScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DayOneExperienceModel

struct __cppobj DayOneExperienceModel : MainMenuScreenModel
{
  std::unique_ptr<LegacyOptionsParser> mOptionsParser;
  const Skin *mLegacySkin;
  bool mLegacySkinRetrievalFinished;
  bool mNeedsRetrievalOnNetworkAvailable;
  std::unique_ptr<Legacy::WorldImporter> mLegacyWorldImporter;
  std::vector<LegacyWorldInfo> mLegacyWorldList;
  bool mLegacyWorldsFetched;
  bool mFetchingLegacyWorldsInProgress;
  bool mFoundLegacyWorlds;
  LegacyWorldConversionManager mLegacyWorldConversionManager;
  std::optional<unsigned int> mImportedWorldIndex;
  CallbackToken mRetrieveCallbackToken;
  CallbackToken mImportCallbackToken;
};

DayOneExperienceModel_vtbl

struct /*VFT*/ DayOneExperienceModel_vtbl
{
  void (__fastcall *~IDlcBatcher)(IDlcBatcher *this);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<PackIdVersion> *);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<std::string> *);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<DlcId> *);
};

DayOneExperienceScreenController

struct __cppobj DayOneExperienceScreenController : MainMenuScreenController
{
  DayOneExperienceWizardTabs mActiveTabIndex;
  bool mInitializedFocus;
  std::shared_ptr<DayOneExperienceModel> mDayOneExperienceModel;
};

DayOneExperienceScreenController_vtbl

struct /*VFT*/ DayOneExperienceScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DeathScreenController

struct __cppobj DeathScreenController : ClientInstanceScreenController
{
  bool mImmediateRespawn;
  bool mRespawnButtonEnabled;
  bool mQuitButtonEnabled;
  bool mLoadingMessageEnabled;
  bool mEverythingVisible;
  bool mForceScreenToLeave;
  bool mStartedBeforeDimensionReady;
  BasicTimer mDelayButtonDisplayTimer;
};

DeathScreenController_vtbl

struct /*VFT*/ DeathScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DebugScreenController

struct __cppobj DebugScreenController : MinecraftScreenController
{
  BasicToggle mIsVisible;
  bool mOptionEnabled;
  BasicToggle mConsoleIsShowing;
  bool mDirty;
  Bedrock::PubSub::ScopedSubscription mDevConsoleOptionSubscription;
};

DebugScreenController_vtbl

struct /*VFT*/ DebugScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DeleteProgressScreenController

struct __cppobj DeleteProgressScreenController : MinecraftScreenController
{
  bool mHasTicked;
  bool mInitiated;
  bool mNext;
  std::string mCalledFrom;
  __int64 mLastAudioProgressNotificationUpdate;
  const __int64 mProgressMessageInterval;
  std::unique_ptr<ProgressHandler> mProgressHandler;
  std::deque<std::unique_ptr<ProgressHandler>> mProgressHandlerList;
};

DeleteProgressScreenController_vtbl

struct /*VFT*/ DeleteProgressScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DisconnectScreenController

struct __cppobj __declspec(align(8)) DisconnectScreenController : MinecraftScreenController
{
  std::string mTitleMessage;
  std::string mTelemetryOverride;
  std::string mDisconnectString;
  bool mLeftLevel;
  const bool mLeaveGame;
  const bool mIsSubClient;
  bool mShowAccountSettingUriButton;
};

DisconnectScreenController_vtbl

struct /*VFT*/ DisconnectScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
  ui::ViewRequest (__fastcall *_processLeaveScreen)(DisconnectScreenController *this);
};

DlcProgressScreenController

struct __cppobj __declspec(align(8)) DlcProgressScreenController : MainMenuScreenController
{
  IDlcBatchModel *mDlcBatch;
  std::function<void __cdecl(bool,bool)> mOnCompleteCallback;
  bool mLeaveScreen;
  bool mShowCloseButton;
  bool mProcessingUpdates;
  bool mDisableExitWhileInProgress;
  __int64 mLastAudioProgressNotificationUpdate;
  const __int64 mProgressMessageInterval;
  _BYTE mProgressState[4];
};

DlcProgressScreenController_vtbl

struct /*VFT*/ DlcProgressScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DynamicContentBindingInformation

struct __cppobj DynamicContentBindingInformation : std::enable_shared_from_this<DynamicContentBindingInformation>
{
  DynamicContentBindingInformation_vtbl *__vftable /*VFT*/;
  Json::Value mData;
  std::function<void __cdecl(Json::Value &)> mOnContentItemChangedCallback;
};

DynamicContentBindingInformation_vtbl

struct /*VFT*/ DynamicContentBindingInformation_vtbl
{
  void (__fastcall *~DynamicContentBindingInformation)(DynamicContentBindingInformation *this);
  void (__fastcall *createBindingData)(DynamicContentBindingInformation *this, const Json::Value *);
};

DynamicFormScreenController

struct __cppobj DynamicFormScreenController : MainMenuScreenController
{
  JsonValidator::Property mValidator;
  std::shared_ptr<DynamicContentBindingInformation> mBindingData;
};

DynamicFormScreenController_vtbl

struct /*VFT*/ DynamicFormScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_48c1bc8012c1f5c2bf2852d422c44ceb>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_48c1bc8012c1f5c2bf2852d422c44ceb>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_a501ee0177864bef5255069b595f4f39>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_a501ee0177864bef5255069b595f4f39>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_42899e28c55e546bac34b58f2686eeb7>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_42899e28c55e546bac34b58f2686eeb7>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_a32910c03ea70d901ed8f6263cecab44>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_a32910c03ea70d901ed8f6263cecab44>
{
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_533523784fe2cc1fb3423946357e7b7e>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_533523784fe2cc1fb3423946357e7b7e>
{
  DynamicFormScreenController::_registerBindings::__l2::<lambda_a32910c03ea70d901ed8f6263cecab44> getAdditionalCollectionIndex;
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_99f68f0faf32523e116639d55e1d6968>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_99f68f0faf32523e116639d55e1d6968>
{
  DynamicFormScreenController::_registerBindings::__l2::<lambda_a32910c03ea70d901ed8f6263cecab44> getAdditionalCollectionIndex;
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_20fd69990388bceeab709e758e0ca4b3>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_20fd69990388bceeab709e758e0ca4b3>
{
  DynamicFormScreenController::_registerBindings::__l2::<lambda_a32910c03ea70d901ed8f6263cecab44> getAdditionalCollectionIndex;
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_96c2e253d01dff95dde623fae33c68f7>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_96c2e253d01dff95dde623fae33c68f7>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_1cc7a21152d4276edd32703dc9bd8dab>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_1cc7a21152d4276edd32703dc9bd8dab>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_4998f2065c3299216d4984b1b03c7c19>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_4998f2065c3299216d4984b1b03c7c19>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_fe905cba24644db54218628ba151a79b>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_fe905cba24644db54218628ba151a79b>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_4bb19b2aa404b7811ba3f5ef8393cc17>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_4bb19b2aa404b7811ba3f5ef8393cc17>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_dc23988444404f9960ee240271e2f87e>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_dc23988444404f9960ee240271e2f87e>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_57dc5bee82e627d416d5a9cc0e7b62a0>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_57dc5bee82e627d416d5a9cc0e7b62a0>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_7c8987ab7757bf9c0ee16bcde70b30a0>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_7c8987ab7757bf9c0ee16bcde70b30a0>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_a7ae59005af0fab59b4cedcaffc40d45>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_a7ae59005af0fab59b4cedcaffc40d45>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_27185b193dd2f38ea9c1d5f7afcaa242>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_27185b193dd2f38ea9c1d5f7afcaa242>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_d68cdbe26ccfa7e2357f66c4b0bdb5e3>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_d68cdbe26ccfa7e2357f66c4b0bdb5e3>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_a9ba9d535bd39c23c1460c22a2ba6f7d>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_a9ba9d535bd39c23c1460c22a2ba6f7d>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_1845302138dbc0791cb5fafbda85f8fc>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_1845302138dbc0791cb5fafbda85f8fc>
{
  DynamicFormScreenController::_registerBindings::__l2::<lambda_a9ba9d535bd39c23c1460c22a2ba6f7d> getNewSliderValue;
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_eb10a186e4af3b96811c4aae1e4b895b>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_eb10a186e4af3b96811c4aae1e4b895b>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_5093d3c99a5b54ccb1179e4e194c5d9b>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_5093d3c99a5b54ccb1179e4e194c5d9b>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_3034bb2353211f8e8fe7176825e69b8c>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_3034bb2353211f8e8fe7176825e69b8c>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_a8613f1feb45c330f01661997de31936>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_a8613f1feb45c330f01661997de31936>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_1bfb9c3669352db8f53a41713b83fa42>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_1bfb9c3669352db8f53a41713b83fa42>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerBindings::__l2::<lambda_3d1b88569d58c5ac027f432d54fa08aa>

struct __cppobj DynamicFormScreenController::_registerBindings::__l2::<lambda_3d1b88569d58c5ac027f432d54fa08aa>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_registerEventHandlers::__l2::<lambda_2348fa47d3ea1d66f9e3ab75f99ecfda>

struct __cppobj DynamicFormScreenController::_registerEventHandlers::__l2::<lambda_2348fa47d3ea1d66f9e3ab75f99ecfda>
{
  DynamicFormScreenController *const __this;
};

DynamicFormScreenController::_handleValidationErrors::__l2::<lambda_022fb0bd9e92bba844dd4db42c3dce21>

struct __cppobj DynamicFormScreenController::_handleValidationErrors::__l2::<lambda_022fb0bd9e92bba844dd4db42c3dce21>
{
  DynamicFormScreenController *const __this;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l12::<lambda_a51812a9c557889a071079b234d9733a>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l12::<lambda_a51812a9c557889a071079b234d9733a>
{
  DropdownScreenController *const __this;
  const std::string collectionName;
  std::function<void __cdecl(int,int)> setValue;
  const std::pair<std::string const ,int> nameValuePair;
  std::function<bool __cdecl(int)> isEnabled;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l12::<lambda_bd97b02530eb1eb5ded0de4b67402355>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l12::<lambda_bd97b02530eb1eb5ded0de4b67402355>
{
  DropdownScreenController *const __this;
  std::function<int __cdecl(int)> getValue;
  const std::pair<std::string const ,int> nameValuePair;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_5835443dfb635f16a0a000d0c3fc8080>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_5835443dfb635f16a0a000d0c3fc8080>
{
  DropdownScreenController *const __this;
  std::function<int __cdecl(int)> getValue;
  const std::unordered_map<int,std::string> valueLabelPairs;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_43dce34777a462b4966c1628271d3b86>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_43dce34777a462b4966c1628271d3b86>
{
  DropdownScreenController *const __this;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_a249bac19cae804721c0fcd125017ed6>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_a249bac19cae804721c0fcd125017ed6>
{
  DropdownScreenController *const __this;
  const std::string collectionName;
  std::function<bool __cdecl(int)> isEnabled;
};

DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_9cd647238fd74febfd1511bf58515347>

struct __cppobj DropdownScreenController::setUpCallbacksForCollectionDropdownOption::__l5::<lambda_9cd647238fd74febfd1511bf58515347>
{
  DropdownScreenController *const __this;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l9::<lambda_510fc66667b95da524b39b4b97a9a65c>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l9::<lambda_510fc66667b95da524b39b4b97a9a65c>
{
  DropdownScreenController *const __this;
  std::function<void __cdecl(int)> setValue;
  const std::pair<std::string const ,int> nameValuePair;
  std::function<bool __cdecl(void)> isEnabled;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l9::<lambda_edebe688210d7a42f549c601268dfb50>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l9::<lambda_edebe688210d7a42f549c601268dfb50>
{
  std::function<int __cdecl(void)> getValue;
  const std::pair<std::string const ,int> nameValuePair;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_93963591524494fc302f0d4d76fc02b6>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_93963591524494fc302f0d4d76fc02b6>
{
  std::function<int __cdecl(void)> getValue;
  const std::unordered_map<int,std::string> valueLabelPairs;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_4c5fbe3b3d2114aa5492f14d198ec1b9>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_4c5fbe3b3d2114aa5492f14d198ec1b9>
{
  DropdownScreenController *const __this;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_a600c2447367094b8154f2ce7103a319>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_a600c2447367094b8154f2ce7103a319>
{
  DropdownScreenController *const __this;
  std::function<bool __cdecl(void)> isEnabled;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_f3d00726b00a9ea38d0ff7e2080c0c00>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l2::<lambda_f3d00726b00a9ea38d0ff7e2080c0c00>
{
  DropdownScreenController *const __this;
};

DropdownScreenController::setUpCallbacksForDropdownOption::__l5::<lambda_fd48456aa629bc31e06877c559099d3c>

struct __cppobj DropdownScreenController::setUpCallbacksForDropdownOption::__l5::<lambda_fd48456aa629bc31e06877c559099d3c>
{
  std::function<bool __cdecl(void)> isEnabled;
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_117db8aa940cd528a3cd0eb9e80c7ae1>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_117db8aa940cd528a3cd0eb9e80c7ae1>
{
  DlcProgressScreenController *const __this;
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_188037700c8fb17bbe9229140a4ab600>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_188037700c8fb17bbe9229140a4ab600>
{
  DlcProgressScreenController *const __this;
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_e83f4840731768867901031ec245f646>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_e83f4840731768867901031ec245f646>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_3b4067df1d53f4b0778f948077a93c02>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_3b4067df1d53f4b0778f948077a93c02>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_aa2e48ef77d66f471564d7158f9ccc61>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_aa2e48ef77d66f471564d7158f9ccc61>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_8cdb3a6b55bd85871b71f62681dfdc8f>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_8cdb3a6b55bd85871b71f62681dfdc8f>
{
  DlcProgressScreenController *const __this;
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_d02b26199f4b591e4bf73dcfccfb7798>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_d02b26199f4b591e4bf73dcfccfb7798>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_02e5d8b192128e1674d671b3d0e75aa8>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_02e5d8b192128e1674d671b3d0e75aa8>
{
  DlcProgressScreenController *const __this;
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_6db3d1e11f771b10dfa827556bb349ab>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_6db3d1e11f771b10dfa827556bb349ab>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_6b69f980cdc6aa419db4f38815798e8e>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_6b69f980cdc6aa419db4f38815798e8e>
{
};

DlcProgressScreenController::_registerBindings::__l2::<lambda_56364e50eb50c413c0895dff3ece25ed>

struct __cppobj DlcProgressScreenController::_registerBindings::__l2::<lambda_56364e50eb50c413c0895dff3ece25ed>
{
  DlcProgressScreenController *const __this;
};

DlcProgressScreenController::_registerEventHandlers::__l2::<lambda_dfb924c348e18777383281e4cae41caa>

struct __cppobj DlcProgressScreenController::_registerEventHandlers::__l2::<lambda_dfb924c348e18777383281e4cae41caa>
{
  DlcProgressScreenController *const __this;
};

DisconnectScreenController::_registerBindings::__l2::<lambda_6fa60e5e80b75c39d599c6a250913b86>

struct __cppobj DisconnectScreenController::_registerBindings::__l2::<lambda_6fa60e5e80b75c39d599c6a250913b86>
{
  DisconnectScreenController *const __this;
};

DisconnectScreenController::_registerBindings::__l2::<lambda_fdfa619efb5614c130c30b739eab062a>

struct __cppobj DisconnectScreenController::_registerBindings::__l2::<lambda_fdfa619efb5614c130c30b739eab062a>
{
};

DisconnectScreenController::_registerBindings::__l2::<lambda_041bc92b47e845d7782c67ab0f0eb583>

struct __cppobj DisconnectScreenController::_registerBindings::__l2::<lambda_041bc92b47e845d7782c67ab0f0eb583>
{
  DisconnectScreenController *const __this;
};

DisconnectScreenController::_registerBindings::__l2::<lambda_2aff3943679996784ad7f5f59cf761fc>

struct __cppobj DisconnectScreenController::_registerBindings::__l2::<lambda_2aff3943679996784ad7f5f59cf761fc>
{
  DisconnectScreenController *const __this;
};

DisconnectScreenController::_registerEventHandlers::__l2::<lambda_9e07d3493cd9e380e1baa669b63311f1>

struct __cppobj DisconnectScreenController::_registerEventHandlers::__l2::<lambda_9e07d3493cd9e380e1baa669b63311f1>
{
  DisconnectScreenController *const __this;
};

DisconnectScreenController::_registerEventHandlers::__l2::<lambda_1b6749bb81d992cc8f45b237df6c5eac>

struct __cppobj DisconnectScreenController::_registerEventHandlers::__l2::<lambda_1b6749bb81d992cc8f45b237df6c5eac>
{
  DisconnectScreenController *const __this;
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_43283bf676770a2eebdff57b8921816a>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_43283bf676770a2eebdff57b8921816a>
{
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_a4db5d35b8ccdd536d9412e1183dda36>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_a4db5d35b8ccdd536d9412e1183dda36>
{
  DeleteProgressScreenController *const __this;
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_519910bceafb03b58f3e731b23c3aacc>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_519910bceafb03b58f3e731b23c3aacc>
{
  DeleteProgressScreenController *const __this;
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_93b6f8659f632376a12f13a52c8a75d2>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_93b6f8659f632376a12f13a52c8a75d2>
{
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_cd5b03df82dbf30736422cc992a115d9>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_cd5b03df82dbf30736422cc992a115d9>
{
};

DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_53c944587a597e9cba3711cf7b743214>

struct __cppobj DeleteProgressScreenController::_registerProgressBindings::__l2::<lambda_53c944587a597e9cba3711cf7b743214>
{
};

DebugScreenController::_registerBindings::__l2::<lambda_aa109d10453ff6983e0fe9377e198c51>

struct __cppobj DebugScreenController::_registerBindings::__l2::<lambda_aa109d10453ff6983e0fe9377e198c51>
{
  DebugScreenController *const __this;
};

DebugScreenController::_registerEventHandlers::__l2::<lambda_2d3e25f98e2f7097c9a463aa940e0c37>

struct __cppobj DebugScreenController::_registerEventHandlers::__l2::<lambda_2d3e25f98e2f7097c9a463aa940e0c37>
{
  DebugScreenController *const __this;
};

DeathScreenController::_registerBindings::__l2::<lambda_092e61a9add23eb1cf4d8070abc65b96>

struct __cppobj DeathScreenController::_registerBindings::__l2::<lambda_092e61a9add23eb1cf4d8070abc65b96>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerBindings::__l2::<lambda_afef51b5777264521dc4b9a3af79fe85>

struct __cppobj DeathScreenController::_registerBindings::__l2::<lambda_afef51b5777264521dc4b9a3af79fe85>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerBindings::__l2::<lambda_2b547032e546d60a0a53b9dfcd3671e2>

struct __cppobj DeathScreenController::_registerBindings::__l2::<lambda_2b547032e546d60a0a53b9dfcd3671e2>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerBindings::__l2::<lambda_0ce57032ff70e59ffe32a9229faf1d68>

struct __cppobj DeathScreenController::_registerBindings::__l2::<lambda_0ce57032ff70e59ffe32a9229faf1d68>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerEventHandlers::__l2::<lambda_628cbc30116fe224f5ea696d9cab7618>

struct __cppobj DeathScreenController::_registerEventHandlers::__l2::<lambda_628cbc30116fe224f5ea696d9cab7618>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerEventHandlers::__l2::<lambda_628cbc30116fe224f5ea696d9cab7618>::()::__l2::<lambda_3812a746fb4210eea053ec5e4bf5002f>

struct __cppobj DeathScreenController::_registerEventHandlers::__l2::<lambda_628cbc30116fe224f5ea696d9cab7618>::()::__l2::<lambda_3812a746fb4210eea053ec5e4bf5002f>
{
  DeathScreenController *const __this;
};

DeathScreenController::_registerEventHandlers::__l2::<lambda_c8e88c4a51bfc81e665e86e07aa227b0>

struct __cppobj DeathScreenController::_registerEventHandlers::__l2::<lambda_c8e88c4a51bfc81e665e86e07aa227b0>
{
  DeathScreenController *const __this;
};

DayOneExperienceScreenController::_getConvertStateCallback::__l2::<lambda_3bc778f4f8ab5301c985c7fac89b17cd>

struct __cppobj DayOneExperienceScreenController::_getConvertStateCallback::__l2::<lambda_3bc778f4f8ab5301c985c7fac89b17cd>
{
  std::weak_ptr<DayOneExperienceScreenController> weakThis;
};

DayOneExperienceScreenController::_getImportProgressHandlerCallback::__l2::<lambda_67f45c17a5a8ed444619a22168be16ca>

struct __cppobj DayOneExperienceScreenController::_getImportProgressHandlerCallback::__l2::<lambda_67f45c17a5a8ed444619a22168be16ca>
{
  std::weak_ptr<DayOneExperienceScreenController> weakThis;
};

DayOneExperienceScreenController::_createSkipModal::__l2::<lambda_2cae5f0fac5b91e971c6c3c7286462c9>

struct __cppobj DayOneExperienceScreenController::_createSkipModal::__l2::<lambda_2cae5f0fac5b91e971c6c3c7286462c9>
{
  std::weak_ptr<DayOneExperienceScreenController> weakThis;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_b345b64a715ddd4c8abc29d5c8697e7c>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_b345b64a715ddd4c8abc29d5c8697e7c>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_11ab86cc53182832491395afb95fac85>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_11ab86cc53182832491395afb95fac85>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_f6fc41ba24f3aeaf7d8a64c441ad64f8>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_f6fc41ba24f3aeaf7d8a64c441ad64f8>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_1a615f295c1d86207206723bcef57f96>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_1a615f295c1d86207206723bcef57f96>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_544c8b02f5aeb0d7ac82900ad0f3e73b>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_544c8b02f5aeb0d7ac82900ad0f3e73b>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_3d987f371873c36320a1971bd35f03ed>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_3d987f371873c36320a1971bd35f03ed>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_5253f968e3e3a176b34b542d5233e53e>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_5253f968e3e3a176b34b542d5233e53e>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_f88365402951cc108eab267068167555>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_f88365402951cc108eab267068167555>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_6c5566e70d0eedd39f4fa0ebb2665b30>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_6c5566e70d0eedd39f4fa0ebb2665b30>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_9aca9ea9f7802b05839db55a2d393124>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_9aca9ea9f7802b05839db55a2d393124>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_75155b4485aeb67994ba40f1de821546>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_75155b4485aeb67994ba40f1de821546>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_ed7a83c49e2021247c2f5ed7c4348411>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_ed7a83c49e2021247c2f5ed7c4348411>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_26540d9ab63233e93e7bab2093301cc1>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_26540d9ab63233e93e7bab2093301cc1>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_6f6b40347a0fb52a14656f1aa64fbcfd>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_6f6b40347a0fb52a14656f1aa64fbcfd>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_511f6d70865d8b1a6bcb485f657529ab>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_511f6d70865d8b1a6bcb485f657529ab>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_c7ea794835efb867d02a12a467200548>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_c7ea794835efb867d02a12a467200548>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_d17767bb7be353031866e00d79d407b5>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_d17767bb7be353031866e00d79d407b5>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerBindings::__l2::<lambda_00dad5d8927cad11e1b19e1b74d5210a>

struct __cppobj DayOneExperienceScreenController::_registerBindings::__l2::<lambda_00dad5d8927cad11e1b19e1b74d5210a>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f10099cf2a5bfbc92fa7d934f63d1af7>

struct __cppobj DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f10099cf2a5bfbc92fa7d934f63d1af7>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f10099cf2a5bfbc92fa7d934f63d1af7>::()::__l2::<lambda_ec2d3148d19dac1bf5194d90e8938643>

struct __cppobj DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f10099cf2a5bfbc92fa7d934f63d1af7>::()::__l2::<lambda_ec2d3148d19dac1bf5194d90e8938643>
{
  bool *bIsLowDiskSpaceWarning;
};

DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_619d0e9cd4b8291b242aa4873679fd41>

struct __cppobj DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_619d0e9cd4b8291b242aa4873679fd41>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f7a41e9a8bf9f1962b47b0d7825c7472>

struct __cppobj DayOneExperienceScreenController::_registerEventHandlers::__l2::<lambda_f7a41e9a8bf9f1962b47b0d7825c7472>
{
  DayOneExperienceScreenController *const __this;
};

DayOneExperienceIntroScreenController::_registerEventHandlers::__l2::<lambda_926ead674856f911228fd83483193a40>

struct __cppobj DayOneExperienceIntroScreenController::_registerEventHandlers::__l2::<lambda_926ead674856f911228fd83483193a40>
{
  DayOneExperienceIntroScreenController *const __this;
};

DayOneExperienceIntroScreenController::_registerEventHandlers::__l2::<lambda_ffc863ee133a35299b221d3ce25fbd0c>

struct __cppobj DayOneExperienceIntroScreenController::_registerEventHandlers::__l2::<lambda_ffc863ee133a35299b221d3ce25fbd0c>
{
  DayOneExperienceIntroScreenController *const __this;
};

Detail::HashHelper<char [45]>

struct __cppobj Detail::HashHelper<char [45]>
{
};

Detail::HashHelper<char [52]>

struct __cppobj Detail::HashHelper<char [52]>
{
};

Detail::HashHelper<char [4]>

struct __cppobj Detail::HashHelper<char [4]>
{
};

Detail::HashHelper<char [46]>

struct __cppobj Detail::HashHelper<char [46]>
{
};

Detail::HashHelper<char [6]>

struct __cppobj Detail::HashHelper<char [6]>
{
};

Detail::HashHelper<char [48]>

struct __cppobj Detail::HashHelper<char [48]>
{
};

Detail::HashHelper<char [56]>

struct __cppobj Detail::HashHelper<char [56]>
{
};

Detail::HashHelper<char [47]>

struct __cppobj Detail::HashHelper<char [47]>
{
};

Detail::HashHelper<char [49]>

struct __cppobj Detail::HashHelper<char [49]>
{
};

Detail::HashHelper<char [42]>

struct __cppobj Detail::HashHelper<char [42]>
{
};

Detail::HashHelper<char [50]>

struct __cppobj Detail::HashHelper<char [50]>
{
};

Detail::HashHelper<char [58]>

struct __cppobj Detail::HashHelper<char [58]>
{
};

Detail::HashHelper<char [53]>

struct __cppobj Detail::HashHelper<char [53]>
{
};

Detail::HashHelper<char [5]>

struct __cppobj Detail::HashHelper<char [5]>
{
};

DefaultLevelDrawSetupCleanupStrategy

struct __cppobj __declspec(align(8)) DefaultLevelDrawSetupCleanupStrategy : AbstractScreenSetupCleanupStrategy
{
  IClientInstance *mClient;
  float mA;
};

DefaultLevelDrawSetupCleanupStrategy_vtbl

struct /*VFT*/ DefaultLevelDrawSetupCleanupStrategy_vtbl
{
  void (__fastcall *~AbstractScreenSetupCleanupStrategy)(AbstractScreenSetupCleanupStrategy *this);
  void (__fastcall *setupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  void (__fastcall *cleanupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  EyeRenderingModeBit (__fastcall *getEyeRenderingMode)(AbstractScreenSetupCleanupStrategy *this);
};

DefaultUIScreenSetupCleanupStrategy

struct __cppobj DefaultUIScreenSetupCleanupStrategy : AbstractScreenSetupCleanupStrategy
{
  IClientInstance *mClient;
};

DefaultUIScreenSetupCleanupStrategy_vtbl

struct /*VFT*/ DefaultUIScreenSetupCleanupStrategy_vtbl
{
  void (__fastcall *~AbstractScreenSetupCleanupStrategy)(AbstractScreenSetupCleanupStrategy *this);
  void (__fastcall *setupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  void (__fastcall *cleanupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  EyeRenderingModeBit (__fastcall *getEyeRenderingMode)(AbstractScreenSetupCleanupStrategy *this);
};

DefaultMonoscopicScreenSetupCleanupStrategy

struct __cppobj DefaultMonoscopicScreenSetupCleanupStrategy : DefaultUIScreenSetupCleanupStrategy
{
};

DefaultMonoscopicScreenSetupCleanupStrategy_vtbl

struct /*VFT*/ DefaultMonoscopicScreenSetupCleanupStrategy_vtbl
{
  void (__fastcall *~AbstractScreenSetupCleanupStrategy)(AbstractScreenSetupCleanupStrategy *this);
  void (__fastcall *setupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  void (__fastcall *cleanupScreen)(AbstractScreenSetupCleanupStrategy *this, ScreenContext *);
  EyeRenderingModeBit (__fastcall *getEyeRenderingMode)(AbstractScreenSetupCleanupStrategy *this);
};

DevConsoleCommandOrigin

struct __cppobj __declspec(align(8)) DevConsoleCommandOrigin : CommandOrigin
{
  ActorUniqueID mPlayerId;
  Level *mLevel;
  NetworkIdentifier mSourceId;
  unsigned __int8 mSourceSubId;
};

DevConsoleCommandOrigin_vtbl

struct /*VFT*/ DevConsoleCommandOrigin_vtbl
{
  void (__fastcall *~CommandOrigin)(CommandOrigin *this);
  const std::string *(__fastcall *getRequestId)(CommandOrigin *this);
  std::string *(__fastcall *getName)(CommandOrigin *this, std::string *result);
  BlockPos *(__fastcall *getBlockPosition)(CommandOrigin *this, BlockPos *result);
  Vec3 *(__fastcall *getWorldPosition)(CommandOrigin *this, Vec3 *result);
  Level *(__fastcall *getLevel)(CommandOrigin *this);
  Dimension *(__fastcall *getDimension)(CommandOrigin *this);
  Actor *(__fastcall *getEntity)(CommandOrigin *this);
  CommandPermissionLevel (__fastcall *getPermissionsLevel)(CommandOrigin *this);
  std::unique_ptr<CommandOrigin> *(__fastcall *clone)(CommandOrigin *this, std::unique_ptr<CommandOrigin> *result);
  std::optional<BlockPos> *(__fastcall *getCursorHitBlockPos)(CommandOrigin *this, std::optional<BlockPos> *result);
  std::optional<Vec3> *(__fastcall *getCursorHitPos)(CommandOrigin *this, std::optional<Vec3> *result);
  bool (__fastcall *hasChatPerms)(CommandOrigin *this);
  bool (__fastcall *hasTellPerms)(CommandOrigin *this);
  bool (__fastcall *canUseAbility)(CommandOrigin *this, AbilitiesIndex);
  bool (__fastcall *isWorldBuilder)(CommandOrigin *this);
  bool (__fastcall *canUseCommandsWithoutCheatsEnabled)(CommandOrigin *this);
  bool (__fastcall *isSelectorExpansionAllowed)(CommandOrigin *this);
  const NetworkIdentifier *(__fastcall *getSourceId)(CommandOrigin *this);
  unsigned __int8 (__fastcall *getSourceSubId)(CommandOrigin *this);
  const CommandOrigin *(__fastcall *getOutputReceiver)(CommandOrigin *this);
  CommandOriginType (__fastcall *getOriginType)(CommandOrigin *this);
  CommandOriginData *(__fastcall *toCommandOriginData)(CommandOrigin *this, CommandOriginData *result);
  const mce::UUID *(__fastcall *getUUID)(CommandOrigin *this);
  void (__fastcall *handleCommandOutputCallback)(CommandOrigin *this, Json::Value *);
  void (__fastcall *_setUUID)(CommandOrigin *this, const mce::UUID *);
};

DlcBatchModel::beginPackDownload::__l5::<lambda_b4c0506a553cc2f2dc82588985e54c91>

struct __cppobj DlcBatchModel::beginPackDownload::__l5::<lambda_b4c0506a553cc2f2dc82588985e54c91>
{
  DlcBatchModel *const __this;
};

DayOneExperienceModel::_onWorldConversionCompleted::__l2::<lambda_7f3628f39ee7691a06d2d3f17aea0b37>::()::__l5::<lambda_33cf5ea085863bdb1cafd5dc701301a7>

struct __cppobj DayOneExperienceModel::_onWorldConversionCompleted::__l2::<lambda_7f3628f39ee7691a06d2d3f17aea0b37>::()::__l5::<lambda_33cf5ea085863bdb1cafd5dc701301a7>
{
  std::weak_ptr<DayOneExperienceModel> weakThis;
};

DayOneExperienceModel::convertLegacyWorld::__l2::<lambda_ff2bb5f1b1b09852d332602081a11a17>

struct __cppobj DayOneExperienceModel::convertLegacyWorld::__l2::<lambda_ff2bb5f1b1b09852d332602081a11a17>
{
};

DayOneExperienceModel::_fetchWorlds::__l2::<lambda_7a646a0b08e3578bb1eb76a3ac9cb7f5>

struct __cppobj DayOneExperienceModel::_fetchWorlds::__l2::<lambda_7a646a0b08e3578bb1eb76a3ac9cb7f5>
{
  std::weak_ptr<DayOneExperienceModel> weakThis;
};

DeviceButtonMapper

struct __cppobj __declspec(align(8)) DeviceButtonMapper : InputDeviceMapper
{
  std::unordered_multimap<int,unsigned int> mDeviceButtonToButtonIdMap;
  int mPrimaryGameControllerId;
};

DeviceButtonMapper_vtbl

struct /*VFT*/ DeviceButtonMapper_vtbl
{
  void (__fastcall *~InputDeviceMapper)(InputDeviceMapper *this);
  void (__fastcall *setMapping)(InputDeviceMapper *this, InputEventQueue *, const BindingFactory *, const InputMapping *, int);
  void (__fastcall *clearMapping)(InputDeviceMapper *this, int);
  void (__fastcall *clearInputDeviceQueue)(InputDeviceMapper *this);
  void (__fastcall *clearInputDeviceQueueForFrame)(InputDeviceMapper *this);
  void (__fastcall *hardResetInputDeviceQueue)(InputDeviceMapper *this);
  bool (__fastcall *tick)(InputDeviceMapper *this, InputEventQueue *, ControllerIDtoClientMap *);
  InputMode (__fastcall *getInputMode)(InputDeviceMapper *this);
  void (__fastcall *getCursorPos)(InputDeviceMapper *this, float *, float *);
  void (__fastcall *render)(InputDeviceMapper *this, InputRenderContext *);
  void (__fastcall *setWindowSize)(InputDeviceMapper *this, int, int);
  void (__fastcall *setBindingMode)(InputDeviceMapper *this, InputBindingMode, int);
  InputBindingMode (__fastcall *getBindingMode)(InputDeviceMapper *this, int);
  void (__fastcall *changeControllerId)(InputDeviceMapper *this, int, int);
};

DeviceButtonEvent

struct DeviceButtonEvent
{
  int id;
  DeviceButtonState state;
};

DragonHeadModel

struct __cppobj DragonHeadModel : Model
{
  float mAnimationPos;
  mce::MaterialPtr mDefaultMaterial;
  mce::MaterialPtr mGlintMaterial;
  ModelPart mHead;
  ModelPart mJaw;
  ModelPart mSnout;
};

DragonHeadModel_vtbl

struct /*VFT*/ DragonHeadModel_vtbl
{
  void (__fastcall *~AppPlatformListener)(AppPlatformListener *this);
  void (__fastcall *onLowMemory)(AppPlatformListener *this);
  void (__fastcall *onAppPaused)(AppPlatformListener *this);
  void (__fastcall *onAppUnpaused)(AppPlatformListener *this);
  void (__fastcall *onAppPreSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppResumed)(AppPlatformListener *this);
  void (__fastcall *onAppFocusLost)(AppPlatformListener *this);
  void (__fastcall *onAppFocusGained)(AppPlatformListener *this);
  void (__fastcall *onAppTerminated)(AppPlatformListener *this);
  void (__fastcall *onOperationModeChanged)(AppPlatformListener *this, const OperationMode);
  void (__fastcall *onPerformanceModeChanged)(AppPlatformListener *this, const bool);
  void (__fastcall *onPushNotificationReceived)(AppPlatformListener *this, const PushNotificationMessage *);
  void (__fastcall *onResizeBegin)(AppPlatformListener *this);
  void (__fastcall *onResizeEnd)(AppPlatformListener *this);
  void (__fastcall *onDeviceLost)(AppPlatformListener *this);
  void (__fastcall *clear)(Model *this);
  void (__fastcall *preDraw)(Model *this, ScreenContext *);
  void (__fastcall *postDraw)(Model *this, ScreenContext *);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *);
  void (__fastcall *render)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, ScreenContext *);
  void (__fastcall *setupAnim)(Model *this);
  void (__fastcall *setupAnim)(Model *this, float, float, float, float, float, float);
  void (__fastcall *prepareMobModel)(Model *this, Mob *, float, float, float);
  Vec3 *(__fastcall *getLeashOffsetPosition)(Model *this, Vec3 *result, bool);
  void (__fastcall *renderAniModel)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  void (__fastcall *renderMod)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *youngTransform)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  float (__fastcall *getHeightAdjustment)(Model *this);
  AABB *(__fastcall *buildAABB)(Model *this, AABB *result);
  void (__fastcall *render)(DragonHeadModel *this, ScreenContext *, float);
};

DataDrivenModel::setupAttachable::__l17::<lambda_88437bb0b9c63badbb13142a0230eacf>

struct __cppobj DataDrivenModel::setupAttachable::__l17::<lambda_88437bb0b9c63badbb13142a0230eacf>
{
  RenderParams *childRenderParams;
  std::shared_ptr<ActorResourceDefinition> *resourceDefinition;
};

DBStorage::CommitOperation

struct __cppobj __declspec(align(8)) DBStorage::CommitOperation
{
  std::string mKey;
  std::shared_ptr<std::string > mValue;
  bool mIsDelete;
};

DragonBreathParticle

struct __cppobj __declspec(align(4)) DragonBreathParticle : Particle
{
  float oSize;
  bool mHasHitGround;
};

DragonBreathParticle_vtbl

struct /*VFT*/ DragonBreathParticle_vtbl
{
  void (__fastcall *init)(Particle *this, const Vec3 *, const Vec3 *, int, ParticleEngine *);
  void (__fastcall *addTagData)(Particle *this, const CompoundTag *);
  void (__fastcall *~Particle)(Particle *this);
  void (__fastcall *normalTick)(Particle *this);
  void (__fastcall *tessellate)(Particle *this, const ParticleRenderContext *);
  const mce::TexturePtr *(__fastcall *getParticleTexture)(Particle *this);
  mce::Color *(__fastcall *getParticleLightColor)(Particle *this, mce::Color *result, float, const LightTexture *);
  void (__fastcall *setEmittingEntity)(Particle *this, Actor *);
  bool (__fastcall *_shouldUpdateVertexData)(Particle *this, float);
};

DripParticle

struct __cppobj __declspec(align(8)) DripParticle : Particle
{
  int stuckTime;
};

DripParticle_vtbl

struct /*VFT*/ DripParticle_vtbl
{
  void (__fastcall *init)(Particle *this, const Vec3 *, const Vec3 *, int, ParticleEngine *);
  void (__fastcall *addTagData)(Particle *this, const CompoundTag *);
  void (__fastcall *~Particle)(Particle *this);
  void (__fastcall *normalTick)(Particle *this);
  void (__fastcall *tessellate)(Particle *this, const ParticleRenderContext *);
  const mce::TexturePtr *(__fastcall *getParticleTexture)(Particle *this);
  mce::Color *(__fastcall *getParticleLightColor)(Particle *this, mce::Color *result, float, const LightTexture *);
  void (__fastcall *setEmittingEntity)(Particle *this, Actor *);
  bool (__fastcall *_shouldUpdateVertexData)(Particle *this, float);
};

DistanceEvents

struct __cppobj DistanceEvents
{
  float distanceInterval;
  std::vector<HashedString> eventName;
};

DataDrivenRenderer_tempComponent_AgentAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_AgentAdditionalRendering : DataDrivenRenderer_tempComponent
{
  ModelPart *mRightArm;
};

DataDrivenRenderer_tempComponent_AgentAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_AgentAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_MushroomCowAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_MushroomCowAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  mce::MaterialPtr mMushroomMaterial;
  BlockTessellator *mBlockTessellator;
  mce::TexturePtr mAtlasTexture;
  ModelPart *mHead;
  ModelPart *mBody;
};

DataDrivenRenderer_tempComponent_MushroomCowAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_MushroomCowAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_HumanoidAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_HumanoidAdditionalRendering : DataDrivenRenderer_tempComponent
{
  std::unique_ptr<SpinAttackModel> mSpinAttackModel;
  std::vector<mce::TexturePtr> mArmorTextures;
  mce::TexturePtr mSpinAttackTex;
  bool mDamageNearbyMobs;
  bool mSneaking;
  float mSwimAmount;
  float mChargeAmount;
  bool mSpear;
  bool mIsGliding;
  float mGlidingSpeedValue;
  float mUseItemStartupProgress;
  float mUseItemIntervalProgress;
  int mUseItemInvervalAxis;
  SkinAdjustments mSkinAdjustments;
  SkinAdjustments mBaseSkinAdjustments;
  float mHoldingHand[2];
  ModelPart *mHead;
  ModelPart *mWaist;
  ModelPart *mBody;
  std::vector<ModelPart *> mRightArm;
  ModelPart *mRightSleeve;
  ModelPart *mLeftArm;
  ModelPart *mLeftSleeve;
  ModelPart *mRightLeg;
  ModelPart *mLeftLeg;
  ModelPart *mRightItem;
  ModelPart *mLeftItem;
  ModelPart *mBodyArmorOffset;
  std::unique_ptr<ModelPart> mBottom;
  std::array<ModelPart *,13> mBindParts;
  DataDrivenRenderer *mRenderer;
  bool mRenderingInventory;
  bool mIsVindicator;
  bool mSetupElytra;
  mce::TextureGroup *mTextures;
};

DataDrivenRenderer_tempComponent_HumanoidAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_HumanoidAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_GuardianAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_GuardianAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  bool mRenderingInventory;
  std::unique_ptr<DataDrivenModel> mGhostModel;
  ModelPart *mHead;
  mce::TexturePtr mElderSkin;
  mce::TexturePtr mBeamSkin;
  mce::MaterialPtr mBeamMaterial;
};

DataDrivenRenderer_tempComponent_GuardianAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_GuardianAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_VexAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_VexAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  ModelPart *mRightArm;
  ModelPart *mRightItem;
};

DataDrivenRenderer_tempComponent_VexAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_VexAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_VillagerAdditionalRendering

struct __cppobj __declspec(align(8)) DataDrivenRenderer_tempComponent_VillagerAdditionalRendering : DataDrivenRenderer_tempComponent
{
  bool mIsWitch;
};

DataDrivenRenderer_tempComponent_VillagerAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_VillagerAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_VillagerV2AdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_VillagerV2AdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  ModelPart *mHeldItem;
};

DataDrivenRenderer_tempComponent_VillagerV2AdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_VillagerV2AdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_IronGolemAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_IronGolemAdditionalRendering : DataDrivenRenderer_tempComponent
{
  BlockTessellator *mBlockTessellator;
  DataDrivenRenderer *mRenderer;
};

DataDrivenRenderer_tempComponent_IronGolemAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_IronGolemAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_PandaAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_PandaAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
};

DataDrivenRenderer_tempComponent_PandaAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_PandaAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_FoxAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_FoxAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
};

DataDrivenRenderer_tempComponent_FoxAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_FoxAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_EnderManAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_EnderManAdditionalRendering : DataDrivenRenderer_tempComponent
{
  BlockTessellator *mBlockTessellator;
  DataDrivenRenderer *mRenderer;
};

DataDrivenRenderer_tempComponent_EnderManAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_EnderManAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_BalloonAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_BalloonAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  mce::MaterialPtr mRopeMaterial;
  mce::TexturePtr mRopeTexture;
};

DataDrivenRenderer_tempComponent_BalloonAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_BalloonAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_MinecartAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_MinecartAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  BlockTessellator *mBlockTessellator;
};

DataDrivenRenderer_tempComponent_MinecartAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_MinecartAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DataDrivenRenderer_tempComponent_SnowGolemAdditionalRendering

struct __cppobj DataDrivenRenderer_tempComponent_SnowGolemAdditionalRendering : DataDrivenRenderer_tempComponent
{
  DataDrivenRenderer *mRenderer;
  mce::Mesh mHead;
  BlockTessellator *mTessellator;
  Matrix mobTransform;
};

DataDrivenRenderer_tempComponent_SnowGolemAdditionalRendering_vtbl

struct /*VFT*/ DataDrivenRenderer_tempComponent_SnowGolemAdditionalRendering_vtbl
{
  void (__fastcall *~DataDrivenRenderer_tempComponent)(DataDrivenRenderer_tempComponent *this);
  void (__fastcall *preRender)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *render)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  void (__fastcall *renderEffects)(DataDrivenRenderer_tempComponent *this, BaseActorRenderContext *, ActorRenderData *, RenderParams *);
  AABB *(__fastcall *getRenderBounds)(DataDrivenRenderer_tempComponent *this, AABB *result, const Actor *);
};

DouseFireSubcomponent

struct __cppobj DouseFireSubcomponent : OnHitSubcomponent
{
};

DouseFireSubcomponent_vtbl

struct /*VFT*/ DouseFireSubcomponent_vtbl
{
  void (__fastcall *~OnHitSubcomponent)(OnHitSubcomponent *this);
  void (__fastcall *readfromJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *writetoJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *doOnHitEffect)(OnHitSubcomponent *this, Actor *, ProjectileComponent *);
  const char *(__fastcall *getName)(OnHitSubcomponent *this);
};

DiodeBlock

struct __cppobj __declspec(align(8)) DiodeBlock : BlockLegacy
{
  bool mOn;
};

DiodeBlock_vtbl

struct /*VFT*/ DiodeBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  int (__fastcall *getSignal)(DiodeBlock *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *isLocked)(DiodeBlock *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isSameDiode)(DiodeBlock *this, const Block *);
  bool (__fastcall *shouldPrioritize)(DiodeBlock *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isOn)(DiodeBlock *this);
  bool (__fastcall *shouldTurnOn)(DiodeBlock *this, BlockSource *, const BlockPos *);
  int (__fastcall *getInputSignal)(DiodeBlock *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAlternateInput)(DiodeBlock *this, const Block *);
  int (__fastcall *getAlternateSignal)(DiodeBlock *this, BlockSource *, const BlockPos *);
  int (__fastcall *getOutputSignal)(DiodeBlock *this, const Block *);
  int (__fastcall *getTurnOffDelay)(DiodeBlock *this, const Block *);
  int (__fastcall *getTurnOnDelay)(DiodeBlock *this, const Block *);
  const Block *(__fastcall *getOnBlock)(DiodeBlock *this, const Block *);
  const Block *(__fastcall *getOffBlock)(DiodeBlock *this, const Block *);
};

DoublePlantBlock

struct __cppobj __declspec(align(8)) DoublePlantBlock : BushBlock
{
  AABB mBottomVisualShape;
};

DoublePlantBlock_vtbl

struct /*VFT*/ DoublePlantBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *checkAlive)(BushBlock *this, BlockSource *, const BlockPos *);
};

DoorBlock

struct __cppobj __declspec(align(8)) DoorBlock : BlockLegacy
{
  DoorBlock::DoorType mType;
};

DoorBlock_vtbl

struct /*VFT*/ DoorBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

dragon::platform::helpers::VisitOverloaded<<lambda_5e329e28c3bfb048584d70281e66d7ac>,<lambda_01b39313f0d7f04e2fa783b22b54c850> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_5e329e28c3bfb048584d70281e66d7ac>,<lambda_01b39313f0d7f04e2fa783b22b54c850> > : RenderChunkGeometry::isMeshValid::__l2::<lambda_5e329e28c3bfb048584d70281e66d7ac>, RenderChunkGeometry::isMeshValid::__l2::<lambda_01b39313f0d7f04e2fa783b22b54c850>
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_b287950b4d7afef2ad2c5a617bf986d3>,<lambda_dbddcd82f0115850bfae3fc5cb4929c1>,<lambda_7279340d92e568c8ba5e036e6d3b050b> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_b287950b4d7afef2ad2c5a617bf986d3>,<lambda_dbddcd82f0115850bfae3fc5cb4929c1>,<lambda_7279340d92e568c8ba5e036e6d3b050b> > : _BYTE[], _BYTE[], _BYTE[]
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_5db1e63c3858a07a833b9dfd6849ade1>,<lambda_dfe3258a647ad9a2780e0b32a3fdd364>,<lambda_18e267ba443016d7f28086e1979fd93e> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_5db1e63c3858a07a833b9dfd6849ade1>,<lambda_dfe3258a647ad9a2780e0b32a3fdd364>,<lambda_18e267ba443016d7f28086e1979fd93e> > : _BYTE[], _BYTE[], _BYTE[]
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_ea86d17e65ca71987d6e1349b02f18e1>,<lambda_f8aed4de4ada8e175dcece725017c8d8>,<lambda_fddf9d9c7b34bb125f126af618f0721d> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_ea86d17e65ca71987d6e1349b02f18e1>,<lambda_f8aed4de4ada8e175dcece725017c8d8>,<lambda_fddf9d9c7b34bb125f126af618f0721d> > : _BYTE[], _BYTE[], _BYTE[]
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_ab713435ef2faa01d8b65aad97412461>,<lambda_21619ba291e1eba153356cbc6994c82d>,<lambda_4ceac7e605773765654d7e544105257d> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_ab713435ef2faa01d8b65aad97412461>,<lambda_21619ba291e1eba153356cbc6994c82d>,<lambda_4ceac7e605773765654d7e544105257d> > : RenderChunkGeometry::prefetchMeshPtr::__l2::<lambda_ab713435ef2faa01d8b65aad97412461>, RenderChunkGeometry::prefetchMeshPtr::__l2::<lambda_21619ba291e1eba153356cbc6994c82d>, RenderChunkGeometry::prefetchMeshPtr::__l2::<lambda_4ceac7e605773765654d7e544105257d>
{
  _BYTE gap0;
};

DefaultGameRendererCompositorStage

struct __cppobj DefaultGameRendererCompositorStage : mce::RenderStageWithDefaultBackBuffer
{
  IClientInstance *mClient;
};

DefaultGameRendererCompositorStage_vtbl

struct /*VFT*/ DefaultGameRendererCompositorStage_vtbl
{
  void (__fastcall *~RenderStage)(mce::RenderStage *this);
  void (__fastcall *preRenderUpdate)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *postRenderUpdate)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *preRender)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *prepareFrame)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *render)(mce::RenderStage *this, ScreenContext *, const FrameRenderObject *);
  void (__fastcall *postRender)(mce::RenderStage *this, ScreenContext *);
  bool (__fastcall *shouldSkip)(mce::RenderStage *this);
  bool (__fastcall *shouldRender)(mce::RenderStage *this);
  void (__fastcall *preparePostProcess)(mce::RenderStage *this, mce::RenderContext *, const mce::TextureDescription *);
};

DefaultUIRendererCompositorStage

struct __cppobj DefaultUIRendererCompositorStage : mce::RenderStage
{
  bool setToBackBuffer;
  IClientInstance *mClient;
  std::unique_ptr<HudDebugOverlayRenderer> mHudDebugOverlayRenderer;
  mce::MaterialPtr mUIQuadMaterial;
  mce::Mesh mUIQuadMesh;
  mce::MaterialPtr mUICursorMaterial;
  mce::Mesh mUICursorMesh;
  bool mUIMeshAvailable;
  float mCursorVPsizeX;
  float mCursorVPsizeY;
  float mCursorGuiScale;
};

DefaultUIRendererCompositorStage_vtbl

struct /*VFT*/ DefaultUIRendererCompositorStage_vtbl
{
  void (__fastcall *~RenderStage)(mce::RenderStage *this);
  void (__fastcall *preRenderUpdate)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *postRenderUpdate)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *preRender)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *prepareFrame)(mce::RenderStage *this, ScreenContext *);
  void (__fastcall *render)(mce::RenderStage *this, ScreenContext *, const FrameRenderObject *);
  void (__fastcall *postRender)(mce::RenderStage *this, ScreenContext *);
  bool (__fastcall *shouldSkip)(mce::RenderStage *this);
  bool (__fastcall *shouldRender)(mce::RenderStage *this);
  void (__fastcall *preparePostProcess)(mce::RenderStage *this, mce::RenderContext *, const mce::TextureDescription *);
};

DefaultUIRendererCompositorStage::postRender::__l2::<lambda_463ef95ee24c1cd6a3bf7714dfca2f39>

struct __cppobj DefaultUIRendererCompositorStage::postRender::__l2::<lambda_463ef95ee24c1cd6a3bf7714dfca2f39>
{
  ScreenContext *screenContext;
};

dragon::result::Result<void,enum MutableGraphicsFrame::SubmitError>

struct dragon::result::Result<void,enum MutableGraphicsFrame::SubmitError>
{
  std::variant<dragon::result::SuccessTag,enum MutableGraphicsFrame::SubmitError> mValue;
};

dragon::platform::helpers::VisitOverloaded<<lambda_2ad54a24c26a56bab19ead12d48483ee>,<lambda_1c7bae9e0e8e75154218cbbb1a06b46f>,<lambda_e3ecd698544eea2955d458a6197fb71e> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_2ad54a24c26a56bab19ead12d48483ee>,<lambda_1c7bae9e0e8e75154218cbbb1a06b46f>,<lambda_e3ecd698544eea2955d458a6197fb71e> > : LevelRendererCamera::queueChunk::__l14::<lambda_2ad54a24c26a56bab19ead12d48483ee>, LevelRendererCamera::queueChunk::__l14::<lambda_1c7bae9e0e8e75154218cbbb1a06b46f>, LevelRendererCamera::queueChunk::__l14::<lambda_e3ecd698544eea2955d458a6197fb71e>
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_f80110362d34345c177c11033da0fab1>,<lambda_a5f77baf381576dd0df113ed6627093f>,<lambda_5f1fe1d401ded85d05fced13872eea5b> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_f80110362d34345c177c11033da0fab1>,<lambda_a5f77baf381576dd0df113ed6627093f>,<lambda_5f1fe1d401ded85d05fced13872eea5b> > : LevelRendererCamera::queueChunk::__l17::<lambda_f80110362d34345c177c11033da0fab1>, LevelRendererCamera::queueChunk::__l17::<lambda_a5f77baf381576dd0df113ed6627093f>, LevelRendererCamera::queueChunk::__l17::<lambda_5f1fe1d401ded85d05fced13872eea5b>
{
  _BYTE gap0;
};

dragon::platform::helpers::VisitOverloaded<<lambda_932f60d2cb0c629a8801fb2f9b1857cd>,<lambda_30b25124c9d435f183601ed482196f94>,<lambda_d0b3d581fe1d9a8f91a95bc4954c799f> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_932f60d2cb0c629a8801fb2f9b1857cd>,<lambda_30b25124c9d435f183601ed482196f94>,<lambda_d0b3d581fe1d9a8f91a95bc4954c799f> > : _BYTE[], _BYTE[], _BYTE[]
{
  _BYTE gap0;
};

DlcImportContext::shouldUnzipToDestination::__l8::<lambda_987d72787e7505b18931e80edea6797f>

struct __cppobj DlcImportContext::shouldUnzipToDestination::__l8::<lambda_987d72787e7505b18931e80edea6797f>
{
  bool *isEncrypted;
};

DX::DeviceResourcesBase

struct __cppobj DX::DeviceResourcesBase
{
};

dragon::mesh::MemoryAccessorTraits<dragon::memory::BufferSource const &>

struct __cppobj dragon::mesh::MemoryAccessorTraits<dragon::memory::BufferSource const &>
{
};

dragon::mesh::MemoryAccessorTraits<dragon::memory::BufferSource &&>

struct __cppobj dragon::mesh::MemoryAccessorTraits<dragon::memory::BufferSource &&>
{
};

dragon::mesh::VertexBufferAllocator

struct __cppobj dragon::mesh::VertexBufferAllocator
{
};

dragon::mesh::RegistryTraits<dragon::mesh::VertexSpanType>

struct __cppobj dragon::mesh::RegistryTraits<dragon::mesh::VertexSpanType>
{
};

dragon::mesh::IndexBufferAllocator

struct __cppobj dragon::mesh::IndexBufferAllocator
{
};

dragon::mesh::RegistryTraits<dragon::mesh::IndexSpanType>

struct __cppobj dragon::mesh::RegistryTraits<dragon::mesh::IndexSpanType>
{
};

dragon::frameobject::components::MeshFilter::VertexBufferUnwrapper

struct __cppobj dragon::frameobject::components::MeshFilter::VertexBufferUnwrapper
{
};

dragon::frameobject::components::MeshFilter::IndexBufferUnwrapper

struct __cppobj dragon::frameobject::components::MeshFilter::IndexBufferUnwrapper
{
};

dragon::frameobject::EntityTransactionBuilder<>

struct __cppobj dragon::frameobject::EntityTransactionBuilder<>
{
  std::tuple<> mComponents;
};

dragon::framegraph::NoLinkerTrace

struct __cppobj dragon::framegraph::NoLinkerTrace
{
};

dragon::rendering::BgfxFrameBufferCache::LeasedFrameBufferHandle

struct __cppobj __declspec(align(2)) dragon::rendering::BgfxFrameBufferCache::LeasedFrameBufferHandle
{
  bgfx::FrameBufferHandle mHandle;
  bool mLeased;
};

dragon::rendering::BgfxFrameBufferCache::DescriptionComparator

struct __cppobj dragon::rendering::BgfxFrameBufferCache::DescriptionComparator
{
};

dragon::rendering::BgfxFrameBufferCache

struct __cppobj dragon::rendering::BgfxFrameBufferCache
{
  std::map<dragon::rendering::BgfxFrameBufferCache::Description,dragon::rendering::BgfxFrameBufferCache::LeasedFrameBufferHandle,dragon::rendering::BgfxFrameBufferCache::DescriptionComparator,std::allocator<std::pair<dragon::rendering::BgfxFrameBufferCache::Description const ,dragon::rendering::BgfxFrameBufferCache::LeasedFrameBufferHandle> > > mCache;
};

dragon::rendering::BgfxTexture2DPool::DescriptionComparator

struct __cppobj dragon::rendering::BgfxTexture2DPool::DescriptionComparator
{
};

dragon::rendering::BgfxTexture2DPool

struct __cppobj dragon::rendering::BgfxTexture2DPool
{
  std::multimap<dragon::rendering::BgfxTexture2DPool::Description,dragon::rendering::BgfxTexture2DPool::LeasedTextureHandle,dragon::rendering::BgfxTexture2DPool::DescriptionComparator,std::allocator<std::pair<dragon::rendering::BgfxTexture2DPool::Description const ,dragon::rendering::BgfxTexture2DPool::LeasedTextureHandle> > > mPool;
  dragon::TextureResourceService mTextureResourceService;
};

dragon::rendering::TextureStatistics

struct __cppobj dragon::rendering::TextureStatistics
{
  bool mWasEverUsed;
  unsigned __int64 mCpuUsedStorageInBytes;
};

dragon::frameobject::PreparedDraw

struct __cppobj __declspec(align(8)) dragon::frameobject::PreparedDraw
{
  const dragon::frameobject::components::MeshFilter *mMeshFilter;
  const dragon::materials::Pass *mPass;
  const dragon::frameobject::components::Transform *mTransform;
  const dragon::frameobject::components::MaterialFilter *mMaterialFilter;
  const unsigned int mDepth;
};

dragon::frameobject::PreparedDrawCollection

struct __cppobj dragon::frameobject::PreparedDrawCollection
{
  std::vector<dragon::frameobject::StateFlagPreparedDraws,Core::CpuRingBufferAllocator<dragon::frameobject::StateFlagPreparedDraws,2,0,Core::CheckedRingBuffer<2,0> > > mStateFlagPreparedDraws;
};

dragon::frameobject::PreparedComputeDispatch

struct __cppobj __declspec(align(8)) dragon::frameobject::PreparedComputeDispatch
{
  const dragon::materials::Pass *mPass;
  const dragon::frameobject::components::MaterialFilter *mMaterialFilter;
  const glm::tvec3<int,0> mThreadGroupCount;
};

dragon::frameobject::PreparedComputeDispatchCollection

struct __cppobj dragon::frameobject::PreparedComputeDispatchCollection
{
  std::vector<dragon::frameobject::PreparedComputeDispatch,Core::CpuRingBufferAllocator<dragon::frameobject::PreparedComputeDispatch,2,0,Core::CheckedRingBuffer<2,0> > > mPreparedDispatches;
};

dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>

struct __cppobj dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>
{
  dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>_vtbl *__vftable /*VFT*/;
};

dragon::framegraph::detail::TransientImageRequest<dragon::rendering::RenderContext>

struct __cppobj dragon::framegraph::detail::TransientImageRequest<dragon::rendering::RenderContext>
{
  dragon::rendering::BgfxTexture2DPool::Description description;
  dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> *owner;
};

dragon::framegraph::detail::LinkingContext<dragon::rendering::RenderContext>

struct __cppobj dragon::framegraph::detail::LinkingContext<dragon::rendering::RenderContext>
{
  std::optional<bool> useBackBuffer;
  std::vector<dragon::framegraph::detail::TransientImageRequest<dragon::rendering::RenderContext>> transientRequests;
  std::variant<std::monostate,dragon::res::ServerTexture,dragon::framegraph::detail::TextureSlice<dragon::rendering::RenderContext>,unsigned __int64> depthAttachment;
  std::array<std::variant<std::monostate,dragon::res::ServerTexture,dragon::framegraph::detail::TextureSlice<dragon::rendering::RenderContext>,unsigned __int64>,16> colorAttachments;
  std::vector<dragon::framegraph::detail::LinkingMaterialTexture<dragon::rendering::RenderContext>> materialTextures;
};

dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>

const struct __cppobj dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>
{
  dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>_vtbl *__vftable /*VFT*/;
};

dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>_vtbl

struct /*VFT*/ dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>_vtbl
{
  void (__fastcall *~AbstractPass<dragon::rendering::RenderContext>)(dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *this);
  void (__fastcall *execute)(dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *this, const dragon::framegraph::ExecutionContext<dragon::rendering::RenderContext> *);
  gsl::basic_string_span<char const ,-1> *(__fastcall *name)(dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *this, gsl::basic_string_span<char const ,-1> *result);
};

dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>_vtbl

struct /*VFT*/ dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>_vtbl
{
  void (__fastcall *~AbstractResource<dragon::rendering::RenderContext>)(dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> *this);
  dragon::framegraph::Error (__fastcall *link)(dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> *this, dragon::framegraph::detail::LinkingContext<dragon::rendering::RenderContext> *, const std::variant<dragon::framegraph::detail::ResourceInitialization,dragon::framegraph::dependency::BindFramebufferColor<dragon::rendering::RenderContext>,dragon::framegraph::dependency::BindFramebufferDepth<dragon::rendering::RenderContext>,dragon::framegraph::dependency::BindMaterialTexture<dragon::rendering::RenderContext> > *);
};

dragon::framegraph::detail::Event<dragon::rendering::RenderContext>

struct __cppobj __declspec(align(8)) dragon::framegraph::detail::Event<dragon::rendering::RenderContext>
{
  dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *pass;
  dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> *resource;
  std::variant<dragon::framegraph::detail::ResourceInitialization,dragon::framegraph::dependency::BindFramebufferColor<dragon::rendering::RenderContext>,dragon::framegraph::dependency::BindFramebufferDepth<dragon::rendering::RenderContext>,dragon::framegraph::dependency::BindMaterialTexture<dragon::rendering::RenderContext> > dependency;
  int nextEvent;
};

dragon::framegraph::Declarator<dragon::rendering::RenderContext>

struct __cppobj dragon::framegraph::Declarator<dragon::rendering::RenderContext>
{
  std::vector<std::unique_ptr<dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext>>> mPasses;
  std::vector<std::unique_ptr<dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext>>> mResources;
  std::vector<dragon::framegraph::detail::Event<dragon::rendering::RenderContext>> mEvents;
  dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *mInitialPass;
  dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *mCurrentPass;
  bool mCurrentPassValid;
  std::map<dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> const *,int,std::less<dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> const *>,std::allocator<std::pair<dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> const * const,int> > > mLeafEventHandles;
};

dragon::rendering::modules::PostFXTaskContext

struct __cppobj dragon::rendering::modules::PostFXTaskContext
{
  unsigned int mWidth;
  unsigned int mHeight;
  const dragon::rendering::RayTracingResources *mRtResources;
};

dragon::rendering::details::ResourceToken

struct __cppobj dragon::rendering::details::ResourceToken
{
  std::string mName;
  const dragon::framegraph::detail::AbstractResource<dragon::rendering::RenderContext> *mResource;
  const dragon::framegraph::detail::AbstractPass<dragon::rendering::RenderContext> *mPredecessor;
};

dragon::rendering::ProcessingPassReference

struct __cppobj dragon::rendering::ProcessingPassReference
{
  dragon::rendering::ProcessingPassReference_vtbl *__vftable /*VFT*/;
  const std::string *mNameReference;
};

dragon::rendering::ProcessingPassReference_vtbl

struct /*VFT*/ dragon::rendering::ProcessingPassReference_vtbl
{
  void (__fastcall *~ProcessingPassReference)(dragon::rendering::ProcessingPassReference *this);
  const void *(__fastcall *getSortKey)(dragon::rendering::ProcessingPassReference *this);
  const std::vector<std::shared_ptr<dragon::rendering::ProcessingPassReference>> *(__fastcall *getDependencies)(dragon::rendering::ProcessingPassReference *this);
  bool (__fastcall *getIsResolved)(dragon::rendering::ProcessingPassReference *this);
  void (__fastcall *resolve)(dragon::rendering::ProcessingPassReference *this);
};

dragon::rendering::details::CustomRenderPassImpl

struct __cppobj dragon::rendering::details::CustomRenderPassImpl
{
  const std::function<void __cdecl(dragon::framegraph::Declarator<dragon::rendering::RenderContext> &)> mTask;
  std::vector<std::shared_ptr<dragon::rendering::ProcessingPassReference>> mDependencies;
  std::vector<std::variant<dragon::rendering::details::ColorBind,dragon::rendering::details::DepthBind,dragon::rendering::details::MaterialBind>> mReferencedResources;
  const std::string mName;
};

dragon::rendering::details::RenderPassImpl<1,1>

struct __cppobj dragon::rendering::details::RenderPassImpl<1,1>
{
  const std::function<void __cdecl(dragon::framegraph::Declarator<dragon::rendering::RenderContext> &,dragon::rendering::ViewDescription const &,std::optional<dragon::rendering::details::DepthBind> const &,std::array<dragon::rendering::details::ColorBind,1> const &,std::vector<std::variant<dragon::rendering::details::ColorBind,dragon::rendering::details::DepthBind,dragon::rendering::details::MaterialBind>> &)> mTask;
  std::vector<std::shared_ptr<dragon::rendering::ProcessingPassReference>> mDependencies;
  std::vector<std::variant<dragon::rendering::details::ColorBind,dragon::rendering::details::DepthBind,dragon::rendering::details::MaterialBind>> mReferencedResources;
  const std::string mName;
};

dragon::rendering::details::RenderPassImpl<0,1>

struct __cppobj dragon::rendering::details::RenderPassImpl<0,1>
{
  const std::function<void __cdecl(dragon::framegraph::Declarator<dragon::rendering::RenderContext> &,dragon::rendering::ViewDescription const &,std::optional<dragon::rendering::details::DepthBind> const &,std::array<dragon::rendering::details::ColorBind,1> const &,std::vector<std::variant<dragon::rendering::details::ColorBind,dragon::rendering::details::DepthBind,dragon::rendering::details::MaterialBind>> &)> mTask;
  std::vector<std::shared_ptr<dragon::rendering::ProcessingPassReference>> mDependencies;
  std::vector<std::variant<dragon::rendering::details::ColorBind,dragon::rendering::details::DepthBind,dragon::rendering::details::MaterialBind>> mReferencedResources;
  const std::string mName;
};

dragon::frameobject::ComputeEntity

struct __cppobj dragon::frameobject::ComputeEntity
{
  const unsigned int mEntity;
  const dragon::frameobject::components::MaterialFilter *mMaterialFilter;
  const dragon::frameobject::components::ComputeDispatch *mDispatch;
};

dragon::frameobject::ComputeEntityCollection

struct __cppobj dragon::frameobject::ComputeEntityCollection
{
  std::vector<dragon::frameobject::ComputeEntity,Core::CpuRingBufferAllocator<dragon::frameobject::ComputeEntity,2,0,Core::CheckedRingBuffer<2,0> > > mComputeEntities;
  std::vector<dragon::frameobject::SortedEntity,Core::CpuRingBufferAllocator<dragon::frameobject::SortedEntity,2,0,Core::CheckedRingBuffer<2,0> > > mSortedEntities;
};

dragon::guarded::Guarded<std::set<__int64>,std::mutex>

struct __cppobj dragon::guarded::Guarded<std::set<__int64>,std::mutex>
{
  std::set<__int64> mValue;
  std::mutex mMutex;
};

dragon::guarded::Guarded<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex>

struct __cppobj dragon::guarded::Guarded<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex>
{
  std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>> mValue;
  std::mutex mMutex;
};

dragon::guarded::Guarded<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex>

struct __cppobj dragon::guarded::Guarded<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex>
{
  std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > > mValue;
  std::mutex mMutex;
};

dragon::CreateVertexBufferTransaction

struct __cppobj dragon::CreateVertexBufferTransaction
{
  std::vector<unsigned char> mBufferData;
  unsigned int mBufferStride;
  unsigned int mCount;
  std::string mDebugName;
  dragon::mesh::VertexFormat mVertexFormat;
};

dragon::CreateIndexBufferTransaction

struct __cppobj dragon::CreateIndexBufferTransaction
{
  std::vector<unsigned char> mBufferData;
  unsigned int mBufferStride;
  unsigned int mCount;
  std::string mDebugName;
};

dragon::AssociativeTraits<dragon::guarded::GuardedAccess<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex,std::unique_lock> >

struct __cppobj dragon::AssociativeTraits<dragon::guarded::GuardedAccess<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex,std::unique_lock> >
{
};

dragon::guarded::GuardedAccess<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex,std::unique_lock>

struct __cppobj dragon::guarded::GuardedAccess<std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > >,std::mutex,std::unique_lock>
{
  std::unordered_map<mce::framebuilder::bgfxbridge::RayTraceableMeshKey,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh>,mce::framebuilder::bgfxbridge::RayTraceableMeshKeyHasher,std::equal_to<mce::framebuilder::bgfxbridge::RayTraceableMeshKey>,std::allocator<std::pair<mce::framebuilder::bgfxbridge::RayTraceableMeshKey const ,std::unique_ptr<mce::framebuilder::bgfxbridge::RayTraceableMesh> > > > *mAccess;
  std::unique_lock<std::mutex> mGuard;
};

dragon::guarded::GuardedAccess<std::set<__int64>,std::mutex,std::unique_lock>

struct __cppobj dragon::guarded::GuardedAccess<std::set<__int64>,std::mutex,std::unique_lock>
{
  std::set<__int64> *mAccess;
  std::unique_lock<std::mutex> mGuard;
};

dragon::platform::helpers::VisitOverloaded<<lambda_e4555f1dd6fbc82c3ded76ae64b196c2>,<lambda_67663f34938a87b2768e91d21781d617>,<lambda_1484a1428a8019bb81e788edb9f1b41d> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_e4555f1dd6fbc82c3ded76ae64b196c2>,<lambda_67663f34938a87b2768e91d21781d617>,<lambda_1484a1428a8019bb81e788edb9f1b41d> > : mce::framebuilder::bgfxbridge::BgfxFrameExtractor::updateExternalTexture::__l5::<lambda_e4555f1dd6fbc82c3ded76ae64b196c2>, mce::framebuilder::bgfxbridge::BgfxFrameExtractor::updateExternalTexture::__l5::<lambda_67663f34938a87b2768e91d21781d617>, mce::framebuilder::bgfxbridge::BgfxFrameExtractor::updateExternalTexture::__l5::<lambda_1484a1428a8019bb81e788edb9f1b41d>
{
};

dragon::AssociativeTraits<dragon::guarded::GuardedAccess<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex,std::unique_lock> >

struct __cppobj dragon::AssociativeTraits<dragon::guarded::GuardedAccess<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex,std::unique_lock> >
{
};

dragon::guarded::GuardedAccess<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex,std::unique_lock>

struct __cppobj dragon::guarded::GuardedAccess<std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>>,std::mutex,std::unique_lock>
{
  std::map<__int64,std::unique_ptr<mce::framebuilder::bgfxbridge::ChunkMetadata>> *mAccess;
  std::unique_lock<std::mutex> mGuard;
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction

struct __cppobj dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa
{
  dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction_vtbl *__vftable /*VFT*/;
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction_vtbl

struct /*VFT*/ dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa
{
  void (__fastcall *complete)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this, dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> *);
  void (__fastcall *~EntityTransaction)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this);
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::DynamicTupleEntityTransaction<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::PlayerUI,dragon::frameobject::components::UIElement,dragon::frameobject::components::RaytraceObject,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa : dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction
{
  std::tuple<std::optional<dragon::frameobject::components::MeshFilter>,std::optional<dragon::frameobject::components::MaterialFilter>,std::optional<dragon::frameobject::components::Transform>,std::optional<dragon::frameobject::components::PassState>,std::optional<dragon::frameobject::components::SortOrigin>,std::optional<dragon::frameobject::components::ViewSetId>,std::optional<dragon::frameobject::components::defaultpasses::Opaque>,std::optional<dragon::frameobject::components::defaultpasses::Transparent>,std::optional<dragon::frameobject::components::defaultpasses::UI>,std::optional<dragon::frameobject::components::defaultpasses::AlphaTest>,std::optional<mce::framebuilder::gamecomponents::TransparentItemInWorldObject>,std::optional<mce::framebuilder::gamecomponents::ItemInHandObject>,std::optional<mce::framebuilder::gamecomponents::PlayerUI>,std::optional<dragon::frameobject::components::UIElement>,std::optional<dragon::frameobject::components::RaytraceObject>,std::optional<dragon::frameobject::components::SceneObject>,std::optional<dragon::frameobject::components::SortIndex> > mComponents;
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::DynamicTupleEntityTransaction<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::PlayerUI,dragon::frameobject::components::UIElement,dragon::frameobject::components::RaytraceObject,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SortIndex>_vtbl

struct /*VFT*/ dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa
{
  void (__fastcall *complete)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this, dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> *);
  void (__fastcall *~EntityTransaction)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this);
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::DynamicTupleEntityTransaction<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::RaytraceObject,dragon::frameobject::components::SceneObject,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::SceneObjectActors>

struct __cppobj dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa : dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction
{
  std::tuple<std::optional<dragon::frameobject::components::MaterialFilter>,std::optional<dragon::frameobject::components::MeshFilter>,std::optional<dragon::frameobject::components::PassState>,std::optional<dragon::frameobject::components::RaytraceObject>,std::optional<dragon::frameobject::components::SceneObject>,std::optional<dragon::frameobject::components::ShadowCaster>,std::optional<dragon::frameobject::components::SortIndex>,std::optional<dragon::frameobject::components::SortOrigin>,std::optional<dragon::frameobject::components::Transform>,std::optional<dragon::frameobject::components::UIElement>,std::optional<dragon::frameobject::components::ViewSetId>,std::optional<dragon::frameobject::components::ForceRasterizationWithMultiply>,std::optional<dragon::frameobject::components::defaultpasses::AlphaTest>,std::optional<dragon::frameobject::components::defaultpasses::Opaque>,std::optional<dragon::frameobject::components::defaultpasses::Transparent>,std::optional<dragon::frameobject::components::defaultpasses::UI>,std::optional<mce::framebuilder::gamecomponents::ItemInHandObject>,std::optional<mce::framebuilder::gamecomponents::PlayerUI>,std::optional<mce::framebuilder::gamecomponents::SceneObjectActors> > mComponents;
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::DynamicTupleEntityTransaction<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::RaytraceObject,dragon::frameobject::components::SceneObject,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::SceneObjectActors>_vtbl

struct /*VFT*/ dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa
{
  void (__fastcall *complete)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this, dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> *);
  void (__fastcall *~EntityTransaction)(dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::EntityTransaction *this);
};

dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SceneObject,dragon::frameobject::components::SceneOverlayObject,dragon::frameobject::components::SceneSky,dragon::frameobject::components::SceneSkyObject,dragon::frameobject::components::SelectionOverlayObject,dragon::frameobject::components::Cubemap,dragon::frameobject::components::ShadowSource,dragon::frameobject::components::ShadowCaster,dragon::frameobject::components::ShadowOverlay,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::ForceRasterization,dragon::frameobject::components::ForceRasterizationWithMultiply,dragon::frameobject::components::RaytraceObject,mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >

struct __cppobj dragon::frameobject::Transaction<dragon::platform::registry::BasicRenderRegistry<dragon::frameobject::components::ComputeDispatch,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,dragon::frameobject::components::defaultpasses::Blit,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::defaultpasses::PostFX,dragon::frameobject::components::defaultpasses::UI,dragon::frameobject::components::LightParameters,dragon::frameobject::components::DirectionalLight,dragon::frameobject::components::AmbientLight,dragon::frameobject::components::PointLight,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ParticleObject,dragon::frameobject::components::PassState,dragon::frameobject::components::PostEffect,dragon::frameobject::components::RenderTa
{
};

dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_c8ae11b118fa3bb0ddfb73f02cb29a6f>

struct __cppobj dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_c8ae11b118fa3bb0ddfb73f02cb29a6f>
{
  bool *hasValue;
};

dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_ffc2a46c7b4fa85a56b3e59057970718>

struct __cppobj dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_ffc2a46c7b4fa85a56b3e59057970718>
{
  bool *hasValue;
  dragon::rendering::SharedTextureHandle *result;
};

dragon::platform::helpers::VisitOverloaded<<lambda_c8ae11b118fa3bb0ddfb73f02cb29a6f>,<lambda_ffc2a46c7b4fa85a56b3e59057970718> >

struct __cppobj dragon::platform::helpers::VisitOverloaded<<lambda_c8ae11b118fa3bb0ddfb73f02cb29a6f>,<lambda_ffc2a46c7b4fa85a56b3e59057970718> > : dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_c8ae11b118fa3bb0ddfb73f02cb29a6f>, dragon::rendering::DeferredResult<dragon::rendering::SharedTextureHandle>::tryGet::__l2::<lambda_ffc2a46c7b4fa85a56b3e59057970718>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &,dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget &,dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId const &>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId const &>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeUnique<>

struct __cppobj dragon::platform::helpers::IsTypeUnique<>
{
};

dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RenderTarget &,dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RenderTarget &,dragon::frameobject::components::ViewSetId const &,mce::framebuilder::gamecomponents::LivingRoomViewFilter>
{
};

dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::VrConfiguration>

struct __cppobj dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::VrConfiguration>
{
};

dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::VrConfiguration>

struct __cppobj dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::VrConfiguration>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowVolume>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowVolume>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::StencilWrite,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowVolume,dragon::frameobject::components::SortIndex>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::ShadowOverlay>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RenderTarget,dragon::frameobject::components::PassState,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::Gameface>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::UI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::UI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::UIElement,dragon::frameobject::components::SortIndex,dragon::frameobject::components::defaultpasses::UI,mce::framebuilder::gamecomponents::OverlayUI>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::SceneOverlayObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Opaque,dragon::frameobject::components::PassState,dragon::frameobject::components::Cubemap>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::SortOrigin,dragon::frameobject::components::defaultpasses::Transparent,dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::InLevelCubeMapObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>

struct __cppobj dragon::platform::helpers::IsTypeUnique<dragon::frameobject::components::Transform,dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::RaytraceObject>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MeshFilter,dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::ViewSetId,dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::Transform,dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::MaterialFilter,dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};

dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>

struct __cppobj dragon::platform::helpers::IsTypeContained<dragon::frameobject::components::PassState,dragon::frameobject::components::defaultpasses::AlphaTest,mce::framebuilder::gamecomponents::AlphaTestCracks>
{
};