234 lines
9.8 KiB
C++
234 lines
9.8 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "MuR/Image.h"
|
|
#include "MuR/Mesh.h"
|
|
#include "MuR/Instance.h"
|
|
#include "MuR/RefCounted.h"
|
|
#include "MuR/Settings.h"
|
|
#include "MuR/Types.h"
|
|
#include "Tasks/Task.h"
|
|
#include "Templates/SharedPointer.h"
|
|
#include "Templates/Tuple.h"
|
|
#include "HAL/Platform.h"
|
|
|
|
#include "System.generated.h"
|
|
|
|
class UTexture;
|
|
class USkeletalMesh;
|
|
|
|
#define UE_API MUTABLERUNTIME_API
|
|
|
|
|
|
/** If set to 1, this enables some expensive Unreal Insights traces, but can lead to 5x slower mutable operation.
|
|
* Other cheaper traces are enabled at all times.
|
|
*/
|
|
#define UE_MUTABLE_ENABLE_SLOW_TRACES 0
|
|
|
|
|
|
/** Despite being an UEnum, this is not always version-serialized (in MutableTools).
|
|
* Beware of changing the enum options or order.
|
|
*/
|
|
UENUM()
|
|
enum class ETextureCompressionStrategy : uint8
|
|
{
|
|
/** Don't change the generated format. */
|
|
None,
|
|
|
|
/** If a texture depends on run-time parameters for an object state, don't compress. */
|
|
DontCompressRuntime,
|
|
|
|
/** Never compress the textures for this state. */
|
|
NeverCompress
|
|
};
|
|
|
|
MUTABLE_DEFINE_ENUM_SERIALISABLE(ETextureCompressionStrategy);
|
|
|
|
|
|
namespace mu
|
|
{
|
|
// Forward references
|
|
class FModel;
|
|
class FModelReader;
|
|
class FParameters;
|
|
class FMesh;
|
|
class FExtensionDataStreamer;
|
|
|
|
|
|
/** */
|
|
enum class EExecutionStrategy : uint8
|
|
{
|
|
/** Undefined. */
|
|
None = 0,
|
|
|
|
/** Always try to run operations that reduce working memory first. */
|
|
MinimizeMemory,
|
|
|
|
/** Always try to run operations that unlock more operations first. */
|
|
MaximizeConcurrency,
|
|
|
|
/** Utility value with the number of error types. */
|
|
Count
|
|
};
|
|
|
|
|
|
/** Interface to request external images used as parameters. */
|
|
class FExternalResourceProvider
|
|
{
|
|
public:
|
|
|
|
//! Ensure virtual destruction
|
|
virtual ~FExternalResourceProvider() = default;
|
|
|
|
/** Returns the completion event and a cleanup function that must be called once event is completed. */
|
|
virtual TTuple<UE::Tasks::FTask, TFunction<void()>> GetImageAsync(UTexture* Texture, uint8 MipmapsToSkip, TFunction<void(TSharedPtr<FImage>)>& ResultCallback) = 0;
|
|
virtual TTuple<UE::Tasks::FTask, TFunction<void()>> GetReferencedImageAsync(const void* ModelPtr, int32 Id, uint8 MipmapsToSkip, TFunction<void(TSharedPtr<FImage>)>& ResultCallback) { check(false); return {}; }
|
|
|
|
virtual mu::FExtendedImageDesc GetImageDesc(UTexture* Texture) = 0;
|
|
|
|
/** Returns the completion event and a cleanup function that must be called once event is completed. */
|
|
virtual TTuple<UE::Tasks::FTask, TFunction<void()>> GetMeshAsync(USkeletalMesh* SkeleltalMesh, int32 InLODIndex, int32 InSectionIndex, TFunction<void(TSharedPtr<FMesh>)>& ResultCallback) = 0;
|
|
};
|
|
|
|
|
|
/** Main system class to load models and build instances. */
|
|
class FSystem
|
|
{
|
|
public:
|
|
|
|
//! This constant can be used in place of the lodMask in methods like BeginUpdate
|
|
static constexpr uint32 AllLODs = 0xffffffff;
|
|
|
|
public:
|
|
|
|
//! Constructor of a system object to build data.
|
|
//! \param Settings Optional class with the settings to use in this system. The default
|
|
//! value configures a production-ready system.
|
|
UE_API FSystem( const FSettings& Settings = FSettings());
|
|
|
|
//! Set a new provider for model data.
|
|
UE_API void SetStreamingInterface(const TSharedPtr<FModelReader>& );
|
|
|
|
/** Set the working memory limit, overrding any set in the settings when the system was created.
|
|
* Refer to Settings::SetWorkingMemoryBudget for more information.
|
|
*/
|
|
UE_API void SetWorkingMemoryBytes( uint64 Bytes );
|
|
|
|
/** Removes all the possible working memory regardless of the budget set. This may make following
|
|
* operations take longer.
|
|
*/
|
|
UE_API void ClearWorkingMemory();
|
|
|
|
/** Set the amount of generated resources keys that will be stored for resource reusal. */
|
|
UE_API void SetGeneratedCacheSize(uint32 InCount);
|
|
|
|
/** Set a new provider for external image data. This is only necessary if image parameters are used in the models. */
|
|
UE_API void SetExternalResourceProvider(const TSharedPtr<FExternalResourceProvider>&);
|
|
|
|
/** Set a function that will be used to convert image pixel formats instead of the internal conversion.
|
|
* \warning The provided function can be called from any thread, and also concurrently.
|
|
* If this function fails (returns false in the first parameter) the internal function is attempted next.
|
|
* This is useful to provide higher-quality external compressors in editor or when cooking.
|
|
*/
|
|
UE_API void SetImagePixelConversionOverride(const FImageOperator::FImagePixelFormatFunc&);
|
|
|
|
//! Create a new instance from the given model. The instance can then be configured through
|
|
//! calls to BeginUpdate/EndUpdate.
|
|
//! A call to NewInstance must be paired to a call to ReleasesInstance when the instance is
|
|
//! no longer needed.
|
|
//! \param pModel Model to build an instance of
|
|
//! \return An identifier that is always bigger than 0.
|
|
UE_API FInstance::FID NewInstance(const TSharedPtr<const FModel>& Model);
|
|
|
|
//! \brief Update an instance with a new parameter set and/or state.
|
|
//!
|
|
//! \warning a call to BeginUpdate must be paired with a call to EndUpdate once the returned
|
|
//! data has been processed.
|
|
//! \param InstanceID The id of the instance to update, as created by a NewInstance call.
|
|
//! \param Params The parameters that customise this instance.
|
|
//! \param StateIndex The index of the state this instance will be set to. The states range
|
|
//! from 0 to Model::GetStateCount-1
|
|
//! \param LodMask Bitmask selecting the levels of detail to build (i-th bit selects i-th lod).
|
|
//! \return the instance data with all the LOD, components, and ids to generate the meshes
|
|
//! and images. The returned Instance is only valid until the next call to EndUpdate with
|
|
//! the same instanceID parameter.
|
|
UE_API TSharedPtr<const FInstance> BeginUpdate(FInstance::FID InstanceID, const TSharedPtr<const FParameters>& Params, int32 StateIndex, uint32 LodMask);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
//! Calculate the description of an image, without generating it.
|
|
UE_API UE::Tasks::TTask<FExtendedImageDesc> GetImageDesc(FInstance::FID InstanceID, FResourceID ImageId);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
//! \param MipsToSkip Number of mips to skip compared from the full image.
|
|
//! If 0, all mip levels will be generated. If more levels than possible to discard are specified,
|
|
//! the image will still contain a minimum number of mips specified at model compile time.
|
|
UE_API UE::Tasks::TTask<TSharedPtr<const FImage>> GetImage(FInstance::FID InstanceID, FResourceID ImageId, int32 MipsToSkip = 0, int32 LOD = 0);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
UE_API UE::Tasks::TTask<TSharedPtr<const FMesh>> GetMesh(FInstance::FID InstanceID, FResourceID MeshId, EMeshContentFlags MeshContentFilter = EMeshContentFlags::AllFlags);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
//! Calculate the description of an image, without generating it.
|
|
UE_API FExtendedImageDesc GetImageDescInline(FInstance::FID InstanceID, FResourceID ImageId);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
//! \param MipsToSkip Number of mips to skip compared from the full image.
|
|
//! If 0, all mip levels will be generated. If more levels than possible to discard are specified,
|
|
//! the image will still contain a minimum number of mips specified at model compile time.
|
|
UE_API TSharedPtr<const FImage> GetImageInline(FInstance::FID InstanceID, FResourceID ImageId, int32 MipsToSkip = 0, int32 LOD = 0);
|
|
|
|
//! Only valid between BeginUpdate and EndUpdate
|
|
UE_API TSharedPtr<const FMesh> GetMeshInline(FInstance::FID InstanceID, FResourceID MeshId, EMeshContentFlags MeshContentFilter = EMeshContentFlags::AllFlags);
|
|
|
|
//! Invalidate and free the last Instance data returned by a call to BeginUpdate with
|
|
//! the same instance index. After a call to this method, that Instance cannot be used any
|
|
//! more and its content is undefined.
|
|
//! \param instance The index of the instance whose last data will be invalidated.
|
|
UE_API void EndUpdate(FInstance::FID InstanceID);
|
|
|
|
//! Completely destroy an instance. After a call to this method the given instance cannot be
|
|
//! updated any more, and its resources may have been freed.
|
|
//! \param instance The id of the instance to destroy.
|
|
UE_API void ReleaseInstance(FInstance::FID InstanceID);
|
|
|
|
//! Calculate the relevancy of every parameter. Some parameters may be unused depending on
|
|
//! the values of other parameters. This method will set to true the flags for parameters
|
|
//! that are relevant, and to false otherwise. This is useful to hide irrelevant parameters
|
|
//! in dynamic user interfaces.
|
|
//! \param pModel The model used to create the FParameters instance.
|
|
//! \param pParameters Parameter set that we want to find the relevancy of.
|
|
//! \param pFlags is a pointer to a preallocated array of booleans that contains at least
|
|
//! pParameters->GetCount() elements.
|
|
UE_API void GetParameterRelevancy( FInstance::FID InstanceID,
|
|
const TSharedPtr<const FParameters>& FParameters,
|
|
bool* Flags );
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
// Interface pattern
|
|
//-----------------------------------------------------------------------------------------
|
|
class Private;
|
|
|
|
UE_API Private* GetPrivate() const;
|
|
|
|
public:
|
|
|
|
// Prevent copy, move and assignment.
|
|
FSystem( const FSystem& ) = delete;
|
|
FSystem& operator=( const FSystem& ) = delete;
|
|
FSystem( FSystem&& ) = delete;
|
|
FSystem& operator=( FSystem&& ) = delete;
|
|
|
|
UE_API ~FSystem();
|
|
|
|
private:
|
|
|
|
Private* m_pD;
|
|
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#undef UE_API
|