GoaLitiuM/FlaxEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Streaming with new settings and textures streaming configuration

Browse Source
This commit is contained in:
Wojtek Figat
2021-06-17 15:33:34 +02:00
parent 64501a8645
commit 4744fa05ef
42 changed files with 631 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Source/Editor/Content/Create/SettingsCreateEntry.cs
View File

@@ -68,6 +68,11 @@ namespace FlaxEditor.Content.Create
/// </summary>
InputSettings,
/// <summary>
/// The streaming settings.
/// </summary>
StreamingSettings,
/// <summary>
/// The Windows settings.
/// </summary>
@@ -116,6 +121,7 @@ namespace FlaxEditor.Content.Create
typeof(LocalizationSettings),
typeof(BuildSettings),
typeof(InputSettings),
typeof(StreamingSettings),
typeof(WindowsPlatformSettings),
typeof(UWPPlatformSettings),
typeof(LinuxPlatformSettings),

11
Source/Editor/Content/Import/TextureImportEntry.cs
View File

@@ -283,6 +283,12 @@ namespace FlaxEditor.Content.Import
[EditorOrder(250), VisibleIf("PreserveAlphaCoverage"), DefaultValue(0.5f), Tooltip("The reference value for the alpha coverage preserving.")]
public float PreserveAlphaCoverageReference { get; set; } = 0.5f;
/// <summary>
/// Texture group for streaming (negative if unused). See Streaming Settings.
/// </summary>
[EditorOrder(300), Tooltip("Texture group for streaming (negative if unused). See Streaming Settings.")]
public int TextureGroup = -1;
/// <summary>
/// The sprites. Used to keep created sprites on sprite atlas reimport.
/// </summary>
@@ -305,6 +311,7 @@ namespace FlaxEditor.Content.Import
public float PreserveAlphaCoverageReference;
public float Scale;
public int MaxSize;
public int TextureGroup;
public Int2 Size;
public Rectangle[] SpriteAreas;
public string[] SpriteNames;
@@ -327,7 +334,8 @@ namespace FlaxEditor.Content.Import
PreserveAlphaCoverageReference = PreserveAlphaCoverageReference,
Scale = Scale,
Size = Size,
MaxSize = (int)MaxSize
MaxSize = (int)MaxSize,
TextureGroup = TextureGroup,
};
if (Sprites != null && Sprites.Count > 0)
{
@@ -362,6 +370,7 @@ namespace FlaxEditor.Content.Import
PreserveAlphaCoverageReference = options.PreserveAlphaCoverageReference;
Scale = options.Scale;
MaxSize = ConvertMaxSize(options.MaxSize);
TextureGroup = options.TextureGroup;
Size = options.Size;
if (options.SpriteAreas != null)
{

17
Source/Editor/Content/PreviewsCache.cpp
View File

@@ -241,16 +241,13 @@ CreateAssetResult PreviewsCache::create(CreateAssetContext& context)
IMPORT_SETUP(PreviewsCache, 4);
// Create texture header (custom data)
TextureHeader header;
header.Width = ASSETS_ICONS_ATLAS_SIZE;
header.Height = ASSETS_ICONS_ATLAS_SIZE;
header.Format = ASSETS_ICONS_ATLAS_FORMAT;
header.IsSRGB = false;
header.IsCubeMap = false;
header.MipLevels = 1;
header.NeverStream = true;
header.Type = TextureFormatType::Unknown;
context.Data.CustomData.Copy(&header);
TextureHeader textureHeader;
textureHeader.Width = ASSETS_ICONS_ATLAS_SIZE;
textureHeader.Height = ASSETS_ICONS_ATLAS_SIZE;
textureHeader.Format = ASSETS_ICONS_ATLAS_FORMAT;
textureHeader.MipLevels = 1;
textureHeader.NeverStream = true;
context.Data.CustomData.Copy(&textureHeader);
// Create blank image (chunk 0)
uint64 imageSize = CalculateTextureMemoryUsage(ASSETS_ICONS_ATLAS_FORMAT, ASSETS_ICONS_ATLAS_SIZE, ASSETS_ICONS_ATLAS_SIZE, 1);

3
Source/Editor/Managed/ManagedEditor.Internal.cpp
View File

@@ -66,6 +66,7 @@ struct InternalTextureOptions
float PreserveAlphaCoverageReference;
float Scale;
int32 MaxSize;
int32 TextureGroup;
int32 SizeX;
int32 SizeY;
MonoArray* SpriteAreas;
@@ -86,6 +87,7 @@ struct InternalTextureOptions
to->PreserveAlphaCoverage = from->PreserveAlphaCoverage;
to->PreserveAlphaCoverageReference = from->PreserveAlphaCoverageReference;
to->MaxSize = from->MaxSize;
to->TextureGroup = from->TextureGroup;
to->SizeX = from->SizeX;
to->SizeY = from->SizeY;
to->Sprites.Clear();
@@ -118,6 +120,7 @@ struct InternalTextureOptions
to->PreserveAlphaCoverageReference = from->PreserveAlphaCoverageReference;
to->Scale = from->Scale;
to->MaxSize = from->MaxSize;
to->TextureGroup = from->TextureGroup;
to->SizeX = from->SizeX;
to->SizeY = from->SizeY;
if (from->Sprites.HasItems())

1
Source/Editor/Modules/ContentDatabaseModule.cs
View File

@@ -940,6 +940,7 @@ namespace FlaxEditor.Modules
Proxy.Add(new SettingsProxy(typeof(AudioSettings), Editor.Instance.Icons.AudioSettings128));
Proxy.Add(new SettingsProxy(typeof(BuildSettings), Editor.Instance.Icons.BuildSettings128));
Proxy.Add(new SettingsProxy(typeof(InputSettings), Editor.Instance.Icons.InputSettings128));
Proxy.Add(new SettingsProxy(typeof(StreamingSettings), Editor.Instance.Icons.BuildSettings128));
Proxy.Add(new SettingsProxy(typeof(WindowsPlatformSettings), Editor.Instance.Icons.WindowsSettings128));
Proxy.Add(new SettingsProxy(typeof(UWPPlatformSettings), Editor.Instance.Icons.UWPSettings128));
Proxy.Add(new SettingsProxy(typeof(LinuxPlatformSettings), Editor.Instance.Icons.LinuxSettings128));

1
Source/Engine/Animations/SceneAnimations/SceneAnimation.cpp
View File

@@ -1,6 +1,7 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "SceneAnimation.h"
#include "Engine/Core/Log.h"
#include "Engine/Content/Factories/BinaryAssetFactory.h"
#include "Engine/Content/Assets/MaterialBase.h"
#include "Engine/Content/Content.h"

1
Source/Engine/Content/Assets/MaterialBase.cpp
View File

@@ -2,6 +2,7 @@
#include "MaterialBase.h"
#include "MaterialInstance.h"
#include "Engine/Core/Log.h"
#include "Engine/Core/Types/Variant.h"
#include "Engine/Content/Content.h"
#include "Engine/Content/Factories/BinaryAssetFactory.h"

1
Source/Engine/Content/Assets/MaterialInstance.cpp
View File

@@ -1,6 +1,7 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "MaterialInstance.h"
#include "Engine/Core/Log.h"
#include "Engine/Core/Types/Variant.h"
#include "Engine/Content/Content.h"
#include "Engine/Content/Upgraders/MaterialInstanceUpgrader.h"

5
Source/Engine/Content/Upgraders/TextureAssetUpgrader.h
View File

@@ -480,7 +480,6 @@ private:
newHeader.IsSRGB = textureHeader.IsSRGB;
newHeader.NeverStream = textureHeader.NeverStream;
newHeader.Type = textureHeader.Type;
newHeader.IsCubeMap = false;
context.Output.CustomData.Copy(&newHeader);
// Convert import options
@@ -535,7 +534,6 @@ private:
newHeader.MipLevels = textureHeader.MipLevels;
newHeader.Format = PixelFormatOldToNew(textureHeader.Format);
newHeader.IsSRGB = textureHeader.IsSRGB;
newHeader.NeverStream = false;
newHeader.Type = TextureFormatType::ColorRGB;
newHeader.IsCubeMap = true;
context.Output.CustomData.Copy(&newHeader);
@@ -617,7 +615,6 @@ private:
newHeader.IsSRGB = textureHeader.IsSRGB;
newHeader.NeverStream = textureHeader.NeverStream;
newHeader.Type = textureHeader.Type;
newHeader.IsCubeMap = false;
context.Output.CustomData.Copy(&newHeader);
// Copy sprite atlas data from old header stream to chunk (chunk 15th)
@@ -696,7 +693,6 @@ private:
newHeader.IsSRGB = textureHeader.IsSRGB;
newHeader.NeverStream = textureHeader.NeverStream;
newHeader.Type = textureHeader.Type;
newHeader.IsCubeMap = false;
auto data = (IESProfile::CustomDataLayout*)newHeader.CustomData;
data->Brightness = brightness;
data->TextureMultiplier = multiplier;
@@ -765,7 +761,6 @@ private:
newHeader.IsSRGB = textureHeader.IsSRGB;
newHeader.NeverStream = textureHeader.NeverStream;
newHeader.Type = textureHeader.Type;
newHeader.IsCubeMap = false;
context.Output.CustomData.Copy(&newHeader);
// Copy asset previews IDs mapping data from old chunk to new one

6
Source/Engine/ContentImporters/ImportTexture.cpp
View File

@@ -168,6 +168,7 @@ CreateAssetResult ImportTexture::Create(CreateAssetContext& context, const Textu
textureHeader.MipLevels = textureData.GetMipLevels();
textureHeader.IsSRGB = PixelFormatExtensions::IsSRGB(textureHeader.Format);
textureHeader.IsCubeMap = isCubeMap;
textureHeader.TextureGroup = options.TextureGroup;
ASSERT(textureHeader.MipLevels <= GPU_MAX_TEXTURE_MIP_LEVELS);
// Save header
@@ -306,6 +307,7 @@ CreateAssetResult ImportTexture::Create(CreateAssetContext& context, const Textu
textureHeader.MipLevels = textureData.Mips.Count();
textureHeader.IsSRGB = PixelFormatExtensions::IsSRGB(textureHeader.Format);
textureHeader.IsCubeMap = isCubeMap;
textureHeader.TextureGroup = options.TextureGroup;
ASSERT(textureHeader.MipLevels <= GPU_MAX_TEXTURE_MIP_LEVELS);
// Save header
@@ -542,12 +544,10 @@ CreateAssetResult ImportTexture::ImportIES(class CreateAssetContext& context)
textureHeader.Width = loader.GetWidth();
textureHeader.Height = loader.GetHeight();
textureHeader.MipLevels = 1;
textureHeader.NeverStream = false;
textureHeader.Type = TextureFormatType::Unknown;
textureHeader.Format = PixelFormat::R16_Float;
textureHeader.IsSRGB = false;
textureHeader.IsCubeMap = false;
auto data = (IESProfile::CustomDataLayout*)textureHeader.CustomData;
static_assert(sizeof(IESProfile::CustomDataLayout) <= sizeof(textureHeader.CustomData), "Invalid Custom Data size in Texture Header.");
data->Brightness = loader.GetBrightness();
data->TextureMultiplier = multiplier;
ASSERT(textureHeader.MipLevels <= GPU_MAX_TEXTURE_MIP_LEVELS);

5
Source/Engine/Core/Config/GameSettings.cpp
View File

@@ -19,6 +19,7 @@
#include "Engine/Content/AssetReference.h"
#include "Engine/Engine/EngineService.h"
#include "Engine/Engine/Globals.h"
#include "Engine/Streaming/StreamingSettings.h"
class GameSettingsService : public EngineService
{
@@ -42,6 +43,7 @@ IMPLEMENT_SETTINGS_GETTER(TimeSettings, Time);
IMPLEMENT_SETTINGS_GETTER(AudioSettings, Audio);
IMPLEMENT_SETTINGS_GETTER(PhysicsSettings, Physics);
IMPLEMENT_SETTINGS_GETTER(InputSettings, Input);
IMPLEMENT_SETTINGS_GETTER(StreamingSettings, Streaming);
#if !USE_EDITOR
#if PLATFORM_WINDOWS
@@ -130,6 +132,7 @@ bool GameSettings::Load()
PRELOAD_SETTINGS(Navigation);
PRELOAD_SETTINGS(Localization);
PRELOAD_SETTINGS(GameCooking);
PRELOAD_SETTINGS(Streaming);
#undef PRELOAD_SETTINGS
// Apply the game settings to the engine
@@ -157,6 +160,7 @@ void GameSettings::Apply()
APPLY_SETTINGS(AudioSettings);
APPLY_SETTINGS(LayersAndTagsSettings);
APPLY_SETTINGS(PhysicsSettings);
APPLY_SETTINGS(StreamingSettings);
APPLY_SETTINGS(InputSettings);
APPLY_SETTINGS(GraphicsSettings);
APPLY_SETTINGS(NavigationSettings);
@@ -202,6 +206,7 @@ void GameSettings::Deserialize(DeserializeStream& stream, ISerializeModifier* mo
DESERIALIZE(Navigation);
DESERIALIZE(Localization);
DESERIALIZE(GameCooking);
DESERIALIZE(Streaming);
// Per-platform settings containers
DESERIALIZE(WindowsPlatform);

10
Source/Engine/Core/Config/GameSettings.cs
View File

@@ -91,6 +91,12 @@ namespace FlaxEditor.Content.Settings
[EditorOrder(1050), EditorDisplay("Other Settings"), AssetReference(typeof(BuildSettings), true), Tooltip("Reference to Build Settings asset")]
public JsonAsset GameCooking;
/// <summary>
/// Reference to <see cref="StreamingSettings"/> asset.
/// </summary>
[EditorOrder(1060), EditorDisplay("Other Settings"), AssetReference(typeof(StreamingSettings), true), Tooltip("Reference to Streaming Settings asset")]
public JsonAsset Streaming;
/// <summary>
/// The custom settings to use with a game. Can be specified by the user to define game-specific options and be used by the external plugins (used as key-value pair).
/// </summary>
@@ -229,6 +235,8 @@ namespace FlaxEditor.Content.Settings
return LoadAsset<LocalizationSettings>(gameSettings.Localization) as T;
if (type == typeof(BuildSettings))
return LoadAsset<BuildSettings>(gameSettings.GameCooking) as T;
if (type == typeof(StreamingSettings))
return LoadAsset<StreamingSettings>(gameSettings.Streaming) as T;
if (type == typeof(InputSettings))
return LoadAsset<InputSettings>(gameSettings.Input) as T;
if (type == typeof(AudioSettings))
@@ -333,6 +341,8 @@ namespace FlaxEditor.Content.Settings
return SaveAsset(gameSettings, ref gameSettings.Localization, obj);
if (type == typeof(BuildSettings))
return SaveAsset(gameSettings, ref gameSettings.GameCooking, obj);
if (type == typeof(StreamingSettings))
return SaveAsset(gameSettings, ref gameSettings.Streaming, obj);
if (type == typeof(InputSettings))
return SaveAsset(gameSettings, ref gameSettings.Input, obj);
if (type == typeof(WindowsPlatformSettings))

1
Source/Engine/Core/Config/GameSettings.h
View File

@@ -70,6 +70,7 @@ public:
Guid Navigation;
Guid Localization;
Guid GameCooking;
Guid Streaming;
// Per-platform settings containers
Guid WindowsPlatform;

10
Source/Engine/Core/Types/StringView.h
View File

@@ -17,6 +17,12 @@ protected:
const T* _data;
int32 _length;
constexpr StringViewBase()
{
_data = nullptr;
_length = 0;
}
public:
/// <summary>
@@ -189,8 +195,6 @@ public:
/// </summary>
constexpr StringView()
{
_data = nullptr;
_length = 0;
}
/// <summary>
@@ -396,8 +400,6 @@ public:
/// </summary>
constexpr StringAnsiView()
{
_data = nullptr;
_length = 0;
}
/// <summary>

37
Source/Engine/Graphics/Textures/StreamingTexture.cpp
View File

@@ -9,6 +9,38 @@
#include "Engine/Graphics/RenderTools.h"
#include "Engine/Graphics/Async/Tasks/GPUUploadTextureMipTask.h"
TextureHeader_Deprecated::TextureHeader_Deprecated()
{
Platform::MemoryClear(this, sizeof(*this));
}
TextureHeader::TextureHeader()
{
Platform::MemoryClear(this, sizeof(*this));
TextureGroup = -1;
}
TextureHeader::TextureHeader(TextureHeader_Deprecated& old)
{
Platform::MemoryClear(this, sizeof(*this));
Width = old.Width;;
Height = old.Height;
MipLevels = old.MipLevels;
Format = old.Format;
Type = old.Type;
if (old.IsCubeMap)
IsCubeMap = 1;
if (old.IsSRGB)
IsSRGB = 1;
if (old.NeverStream)
NeverStream = 1;
TextureGroup = -1;
Platform::MemoryCopy(CustomData, old.CustomData, sizeof(CustomData));
}
static_assert(sizeof(TextureHeader_Deprecated) == 10 * sizeof(int32), "Invalid TextureHeader size.");
static_assert(sizeof(TextureHeader) == 36, "Invalid TextureHeader size.");
StreamingTexture::StreamingTexture(ITextureOwner* parent, const String& name)
: StreamableResource(StreamingGroups::Instance()->Textures())
, _owner(parent)
@@ -112,6 +144,11 @@ String StreamingTexture::ToString() const
return _texture->ToString();
}
int32 StreamingTexture::GetMaxResidency() const
{
return _header.MipLevels;
}
int32 StreamingTexture::GetCurrentResidency() const
{
return _texture->ResidentMipLevels();

7
Source/Engine/Graphics/Textures/StreamingTexture.h
View File

@@ -7,7 +7,7 @@
#include "Types.h"
/// <summary>
/// GPU texture object which can change it's resolution (quality) at runtime
/// GPU texture object which can change it's resolution (quality) at runtime.
/// </summary>
class FLAXENGINE_API StreamingTexture : public Object, public StreamableResource
{
@@ -180,10 +180,7 @@ public:
String ToString() const override;
// [StreamableResource]
int32 GetMaxResidency() const override
{
return _header.MipLevels;
}
int32 GetMaxResidency() const override;
int32 GetCurrentResidency() const override;
int32 GetAllocatedResidency() const override;
bool CanBeUpdated() const override;

64
Source/Engine/Graphics/Textures/TextureBase.cpp
View File

@@ -29,27 +29,27 @@ Vector2 TextureBase::Size() const
int32 TextureBase::GetArraySize() const
{
return StreamingTexture()->TotalArraySize();
return _texture.TotalArraySize();
}
int32 TextureBase::GetMipLevels() const
{
return StreamingTexture()->TotalMipLevels();
return _texture.TotalMipLevels();
}
int32 TextureBase::GetResidentMipLevels() const
{
return GetTexture()->ResidentMipLevels();
return _texture.GetTexture()->ResidentMipLevels();
}
uint64 TextureBase::GetCurrentMemoryUsage() const
{
return GetTexture()->GetMemoryUsage();
return _texture.GetTexture()->GetMemoryUsage();
}
uint64 TextureBase::GetTotalMemoryUsage() const
{
return StreamingTexture()->GetTotalMemoryUsage();
return _texture.GetTotalMemoryUsage();
}
BytesContainer TextureBase::GetMipData(int32 mipIndex, int32& rowPitch, int32& slicePitch)
@@ -166,16 +166,15 @@ bool TextureBase::Init(InitData* initData)
_customData = initData;
// Create texture
TextureHeader header;
header.Format = initData->Format;
header.Width = initData->Width;
header.Height = initData->Height;
header.IsCubeMap = initData->ArraySize == 6;
header.MipLevels = initData->Mips.Count();
header.IsSRGB = false;
header.Type = TextureFormatType::ColorRGBA;
header.NeverStream = true;
if (_texture.Create(header))
TextureHeader textureHeader;
textureHeader.Format = initData->Format;
textureHeader.Width = initData->Width;
textureHeader.Height = initData->Height;
textureHeader.IsCubeMap = initData->ArraySize == 6;
textureHeader.MipLevels = initData->Mips.Count();
textureHeader.Type = TextureFormatType::ColorRGBA;
textureHeader.NeverStream = true;
if (_texture.Create(textureHeader))
{
LOG(Warning, "Cannot initialize texture.");
return true;
@@ -289,6 +288,41 @@ bool TextureBase::GetMipDataCustomPitch(int32 mipIndex, uint32& rowPitch, uint32
return result;
}
bool TextureBase::init(AssetInitData& initData)
{
if (IsVirtual())
return false;
if (initData.SerializedVersion != TexturesSerializedVersion)
{
LOG(Error, "Invalid serialized texture version.");
return true;
}
// Get texture header for asset custom data (fast access)
TextureHeader textureHeader;
if (initData.CustomData.Length() == sizeof(TextureHeader))
{
Platform::MemoryCopy(&textureHeader, initData.CustomData.Get(), sizeof(textureHeader));
}
else if (initData.CustomData.Length() == sizeof(TextureHeader_Deprecated))
{
textureHeader = TextureHeader(*(TextureHeader_Deprecated*)initData.CustomData.Get());
}
else
{
LOG(Error, "Missing texture header.");
return true;
}
return _texture.Create(textureHeader);
}
Asset::LoadResult TextureBase::load()
{
// Loading textures is very fast xD
return LoadResult::Ok;
}
bool TextureBase::InitData::GenerateMip(int32 mipIndex, bool linear)
{
// Validate input

45
Source/Engine/Graphics/Textures/TextureBase.h
View File

@@ -4,7 +4,6 @@
#include "Engine/Content/BinaryAsset.h"
#include "StreamingTexture.h"
#include "Engine/Core/Log.h"
class TextureData;
@@ -15,12 +14,8 @@ class TextureData;
API_CLASS(Abstract, NoSpawn) class FLAXENGINE_API TextureBase : public BinaryAsset, public ITextureOwner
{
DECLARE_ASSET_HEADER(TextureBase);
public:
static const uint32 TexturesSerializedVersion = 4;
public:
/// <summary>
/// The texture init data (external source).
/// </summary>
@@ -180,43 +175,7 @@ public:
protected:
// [BinaryAsset]
bool init(AssetInitData& initData) override
{
// Skip for virtual assets
if (IsVirtual())
return false;
// Validate
if (initData.SerializedVersion != 4)
{
LOG(Error, "Invalid serialized texture version.");
return true;
}
if (initData.CustomData.Length() != sizeof(TextureHeader))
{
LOG(Error, "Missing texture header.");
return true;
}
// Load header
TextureHeader header;
Platform::MemoryCopy(&header, initData.CustomData.Get(), sizeof(TextureHeader));
// Create texture
if (_texture.Create(header))
{
LOG(Error, "Cannot initialize texture.");
return true;
}
return false;
}
LoadResult load() override
{
// Loading textures is very fast xD
return LoadResult::Ok;
}
bool init(AssetInitData& initData) override;
LoadResult load() override;
void unload(bool isReloading) override;
};

55
Source/Engine/Graphics/Textures/Types.h
View File

@@ -12,25 +12,53 @@
DECLARE_ENUM_EX_7(TextureFormatType, byte, 0, Unknown, ColorRGB, ColorRGBA, NormalMap, GrayScale, HdrRGBA, HdrRGB);
/// <summary>
/// Texture header structure
/// Old texture header structure (was not fully initialized to zero).
/// </summary>
struct TextureHeader_Deprecated
{
int32 Width;
int32 Height;
int32 MipLevels;
PixelFormat Format;
TextureFormatType Type;
bool IsCubeMap;
bool NeverStream;
bool IsSRGB;
byte CustomData[17];
TextureHeader_Deprecated();
};
/// <summary>
/// Texture header structure.
/// </summary>
struct FLAXENGINE_API TextureHeader
{
/// <summary>
/// Top mip width in pixels
/// Width in pixels
/// </summary>
int32 Width;
/// <summary>
/// Top mip height in pixels
/// Height in pixels
/// </summary>
int32 Height;
/// <summary>
/// Depth in pixels
/// </summary>
int32 Depth;
/// <summary>
/// Amount of mip levels
/// </summary>
int32 MipLevels;
/// <summary>
/// Texture group for streaming (negative if unused).
/// </summary>
int32 TextureGroup;
/// <summary>
/// Texture pixels format
/// </summary>
@@ -44,22 +72,23 @@ struct FLAXENGINE_API TextureHeader
/// <summary>
/// True if texture is a cubemap (has 6 array slices per mip).
/// </summary>
bool IsCubeMap;
/// <summary>
/// True if disable dynamic texture streaming
/// </summary>
bool NeverStream;
byte IsCubeMap : 1;
/// <summary>
/// True if texture contains sRGB colors data
/// </summary>
bool IsSRGB;
byte IsSRGB : 1;
/// <summary>
/// True if disable dynamic texture streaming
/// </summary>
byte NeverStream : 1;
/// <summary>
/// The custom data to be used per texture storage layer (faster access).
/// </summary>
byte CustomData[17];
};
byte CustomData[10];
static_assert(sizeof(TextureHeader) == 10 * sizeof(int32), "Invalid TextureHeader size.");
TextureHeader();
TextureHeader(TextureHeader_Deprecated& old);
};

1
Source/Engine/Physics/CollisionData.cpp
View File

@@ -1,6 +1,7 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "CollisionData.h"
#include "Engine/Core/Log.h"
#include "Engine/Content/Content.h"
#include "Engine/Content/Assets/Model.h"
#include "Engine/Content/Factories/BinaryAssetFactory.h"

16
Source/Engine/Streaming/Config.h
View File

@@ -1,16 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
// Resources streaming types
typedef float StreamingQuality;
#define MIN_STREAMING_QUALITY 0.0f
#define MAX_STREAMING_QUALITY 1.0f
/// <summary>
/// Enables/disables dynamic resources streaming feature
/// </summary>
#define ENABLE_RESOURCES_DYNAMIC_STREAMING 1
class StreamableResource;

67
Source/Engine/Streaming/Handlers/AudioStreamingHandler.cpp
View File

@@ -1,67 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "AudioStreamingHandler.h"
#include "Engine/Audio/AudioClip.h"
#include "Engine/Audio/Audio.h"
#include "Engine/Audio/AudioSource.h"
StreamingQuality AudioStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
// Audio clips don't use quality but only residency
return MAX_STREAMING_QUALITY;
}
int32 AudioStreamingHandler::CalculateResidency(StreamableResource* resource, StreamingQuality quality)
{
ASSERT(resource);
auto clip = static_cast<AudioClip*>(resource);
const int32 chunksCount = clip->Buffers.Count();
bool chunksMask[ASSET_FILE_DATA_CHUNKS];
Platform::MemoryClear(chunksMask, sizeof(chunksMask));
// Find audio chunks required for streaming
clip->StreamingQueue.Clear();
for (int32 sourceIndex = 0; sourceIndex < Audio::Sources.Count(); sourceIndex++)
{
// TODO: collect refs to audio clip from sources and use faster iteration (but do it thread-safe)
const auto src = Audio::Sources[sourceIndex];
if (src->Clip == clip && src->GetState() == AudioSource::States::Playing)
{
// Stream the current and the next chunk if could be used in a while
const int32 chunk = src->_streamingFirstChunk;
ASSERT(Math::IsInRange(chunk, 0, chunksCount));
chunksMask[chunk] = true;
const float StreamingDstSec = 2.0f;
if (chunk + 1 < chunksCount && src->GetTime() + StreamingDstSec >= clip->GetBufferStartTime(src->_streamingFirstChunk))
{
chunksMask[chunk + 1] = true;
}
}
}
// Try to enqueue chunks to modify (load or unload)
for (int32 i = 0; i < chunksCount; i++)
{
if (chunksMask[i] != (clip->Buffers[i] != 0))
{
clip->StreamingQueue.Add(i);
}
}
return clip->StreamingQueue.Count();
}
int32 AudioStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
// No smoothing or slowdown in residency change
return targetResidency;
}
bool AudioStreamingHandler::RequiresStreaming(StreamableResource* resource, int32 currentResidency, int32 targetResidency)
{
// Audio clips use streaming queue buffer to detect streaming request start
const auto clip = static_cast<AudioClip*>(resource);
return clip->StreamingQueue.HasItems();
}

20
Source/Engine/Streaming/Handlers/AudioStreamingHandler.h
View File

@@ -1,20 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Streaming/IStreamingHandler.h"
/// <summary>
/// Implementation of IStreamingHandler for audio resources.
/// </summary>
/// <seealso cref="IStreamingHandler" />
class FLAXENGINE_API AudioStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
StreamingQuality CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, StreamingQuality quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
bool RequiresStreaming(StreamableResource* resource, int32 currentResidency, int32 targetResidency) override;
};

50
Source/Engine/Streaming/Handlers/ModelsStreamingHandler.cpp
View File

@@ -1,50 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "ModelsStreamingHandler.h"
#include "Engine/Content/Assets/Model.h"
StreamingQuality ModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
ASSERT(resource);
// TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
return MAX_STREAMING_QUALITY;
}
int32 ModelsStreamingHandler::CalculateResidency(StreamableResource* resource, StreamingQuality quality)
{
ASSERT(resource);
auto& model = *(Model*)resource;
auto lodCount = model.GetLODsCount();
if (quality < ZeroTolerance)
return 0;
int32 lods = Math::CeilToInt(quality * (StreamingQuality)lodCount);
ASSERT(model.IsValidLODIndex(lods - 1));
return lods;
}
int32 ModelsStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& model = *(Model*)resource;
// Always load only single LOD at once
int32 residency = targetResidency;
int32 currentResidency = model.GetCurrentResidency();
if (currentResidency < targetResidency)
{
// Up
residency = currentResidency + 1;
}
else if (currentResidency > targetResidency)
{
// Down
residency = currentResidency - 1;
}
return residency;
}

19
Source/Engine/Streaming/Handlers/ModelsStreamingHandler.h
View File

@@ -1,19 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Streaming/IStreamingHandler.h"
/// <summary>
/// Implementation of IStreamingHandler for streamable models.
/// </summary>
/// <seealso cref="IStreamingHandler" />
class FLAXENGINE_API ModelsStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
StreamingQuality CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, StreamingQuality quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};

50
Source/Engine/Streaming/Handlers/SkinnedModelsStreamingHandler.cpp
View File

@@ -1,50 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "SkinnedModelsStreamingHandler.h"
#include "Engine/Content/Assets/SkinnedModel.h"
StreamingQuality SkinnedModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
ASSERT(resource);
// TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
return MAX_STREAMING_QUALITY;
}
int32 SkinnedModelsStreamingHandler::CalculateResidency(StreamableResource* resource, StreamingQuality quality)
{
ASSERT(resource);
auto& model = *(SkinnedModel*)resource;
auto lodCount = model.GetLODsCount();
if (quality < ZeroTolerance)
return 0;
int32 lods = Math::CeilToInt(quality * lodCount);
ASSERT(model.IsValidLODIndex(lods - 1));
return lods;
}
int32 SkinnedModelsStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& model = *(SkinnedModel*)resource;
// Always load only single LOD at once
int32 residency = targetResidency;
int32 currentResidency = model.GetCurrentResidency();
if (currentResidency < targetResidency)
{
// Up
residency = currentResidency + 1;
}
else if (currentResidency > targetResidency)
{
// Down
residency = currentResidency - 1;
}
return residency;
}

19
Source/Engine/Streaming/Handlers/SkinnedModelsStreamingHandler.h
View File

@@ -1,19 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Streaming/IStreamingHandler.h"
/// <summary>
/// Implementation of IStreamingHandler for streamable skinned models.
/// </summary>
/// <seealso cref="IStreamingHandler" />
class FLAXENGINE_API SkinnedModelsStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
StreamingQuality CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, StreamingQuality quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};

71
Source/Engine/Streaming/Handlers/TexturesStreamingHandler.cpp
View File

@@ -1,71 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "TexturesStreamingHandler.h"
#include "Engine/Core/Math/Math.h"
#include "Engine/Graphics/Textures/StreamingTexture.h"
StreamingQuality TexturesStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
// TODO: calculate a proper quality levels for the textures
//return 0.5f;
return MAX_STREAMING_QUALITY;
}
int32 TexturesStreamingHandler::CalculateResidency(StreamableResource* resource, StreamingQuality quality)
{
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
ASSERT(texture.IsInitialized());
const auto totalMipLevels = texture.TotalMipLevels();
if (quality < ZeroTolerance)
{
return 0;
}
int32 mipLevels = Math::CeilToInt(quality * totalMipLevels);
if (mipLevels > 0 && mipLevels < 3 && totalMipLevels > 1 && texture.IsBlockCompressed())
{
// Block compressed textures require minimum size of 4 (3 mips or more)
mipLevels = 3;
}
ASSERT(Math::IsInRange(mipLevels, 0, totalMipLevels));
return mipLevels;
}
int32 TexturesStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
ASSERT(texture.IsInitialized());
int32 residency = targetResidency;
int32 currentResidency = texture.GetCurrentResidency();
// Check if go up or down
if (currentResidency < targetResidency)
{
// Up
residency = Math::Min(currentResidency + 2, targetResidency);
// Stream first a few mips very fast (they are very small)
const int32 QuickStartMipsCount = 6;
if (currentResidency == 0)
{
residency = Math::Min(QuickStartMipsCount, targetResidency);
}
}
else if (currentResidency > targetResidency)
{
// Down at once
residency = targetResidency;
}
return residency;
}

19
Source/Engine/Streaming/Handlers/TexturesStreamingHandler.h
View File

@@ -1,19 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Streaming/IStreamingHandler.h"
/// <summary>
/// Implementation of IStreamingHandler for streamable textures.
/// </summary>
/// <seealso cref="IStreamingHandler" />
class FLAXENGINE_API TexturesStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
StreamingQuality CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, StreamingQuality quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};

16
Source/Engine/Streaming/IStreamingHandler.h
View File

@@ -2,13 +2,13 @@
#pragma once
#include "Config.h"
#include "Engine/Core/Types/DateTime.h"
#include "Engine/Core/Types/BaseTypes.h"
class StreamingGroup;
class StreamableResource;
/// <summary>
/// Base interface for all streamable resource handlers
/// Base interface for all streamable resource handlers that implement resource streaming policy.
/// </summary>
class FLAXENGINE_API IStreamingHandler
{
@@ -19,20 +19,20 @@ public:
public:
/// <summary>
/// Calculates target quality level for the given resource.
/// Calculates target quality level (0-1) for the given resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="now">The current time.</param>
/// <returns>Target Quality</returns>
virtual StreamingQuality CalculateTargetQuality(StreamableResource* resource, DateTime now) = 0;
/// <returns>Target quality (0-1).</returns>
virtual float CalculateTargetQuality(StreamableResource* resource, DateTime now) = 0;
/// <summary>
/// Calculates the residency level for a given resource and quality level.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="quality">The quality level.</param>
/// <param name="quality">The quality level (0-1).</param>
/// <returns>Residency level</returns>
virtual int32 CalculateResidency(StreamableResource* resource, StreamingQuality quality) = 0;
virtual int32 CalculateResidency(StreamableResource* resource, float quality) = 0;
/// <summary>
/// Calculates the residency level to stream for a given resource and target residency.

8
Source/Engine/Streaming/StreamableResource.cpp
View File

@@ -1,13 +1,13 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "StreamableResource.h"
#include "StreamingManager.h"
#include "Streaming.h"
StreamableResource::StreamableResource(StreamingGroup* group)
: _group(group)
, _isDynamic(true)
, _isStreaming(false)
, _streamingQuality(MAX_STREAMING_QUALITY)
, _streamingQuality(1.0f)
{
ASSERT(_group != nullptr);
}
@@ -23,7 +23,7 @@ void StreamableResource::startStreaming(bool isDynamic)
if (_isStreaming == false)
{
StreamingManager::Resources.Add(this);
Streaming::Resources.Add(this);
_isStreaming = true;
}
}
@@ -32,7 +32,7 @@ void StreamableResource::stopStreaming()
{
if (_isStreaming == true)
{
StreamingManager::Resources.Remove(this);
Streaming::Resources.Remove(this);
Streaming = StreamingCache();
_isStreaming = false;
}

11
Source/Engine/Streaming/StreamableResource.h
View File

@@ -4,7 +4,6 @@
#include "Engine/Core/Types/DateTime.h"
#include "Engine/Core/Collections/SamplesBuffer.h"
#include "Config.h"
class StreamingGroup;
class Task;
@@ -18,7 +17,7 @@ protected:
StreamingGroup* _group;
bool _isDynamic, _isStreaming;
StreamingQuality _streamingQuality;
float _streamingQuality;
StreamableResource(StreamingGroup* group);
~StreamableResource();
@@ -38,17 +37,13 @@ public:
/// </summary>
FORCE_INLINE bool IsDynamic() const
{
#if ENABLE_RESOURCES_DYNAMIC_STREAMING
return _isDynamic;
#else
return false;
#endif
}
/// <summary>
/// Gets resource streaming quality level
/// </summary>
FORCE_INLINE StreamingQuality GetStreamingQuality() const
FORCE_INLINE float GetStreamingQuality() const
{
return _streamingQuality;
}
@@ -114,7 +109,7 @@ public:
DateTime LastUpdate = 0;
int32 TargetResidency = 0;
DateTime TargetResidencyChange = 0;
SamplesBuffer<StreamingQuality, 5> QualitySamples;
SamplesBuffer<float, 5> QualitySamples;
};
StreamingCache Streaming;

28
Source/Engine/Streaming/StreamingManager.cpp → Source/Engine/Streaming/Streaming.cpp
View File

@@ -1,13 +1,15 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "StreamingManager.h"
#include "Streaming.h"
#include "StreamableResource.h"
#include "StreamingGroup.h"
#include "StreamingSettings.h"
#include "Engine/Engine/EngineService.h"
#include "Engine/Profiler/ProfilerCPU.h"
#include "Engine/Threading/Threading.h"
#include "Engine/Threading/Task.h"
#include "Engine/Graphics/GPUDevice.h"
#include "Engine/Serialization/Serialization.h"
namespace StreamingManagerImpl
{
@@ -21,7 +23,6 @@ using namespace StreamingManagerImpl;
class StreamingManagerService : public EngineService
{
public:
StreamingManagerService()
: EngineService(TEXT("Streaming Manager"), 100)
{
@@ -32,7 +33,18 @@ public:
StreamingManagerService StreamingManagerServiceInstance;
StreamableResourcesCollection StreamingManager::Resources;
StreamableResourcesCollection Streaming::Resources;
Array<TextureGroup, InlinedAllocation<32>> Streaming::TextureGroups;
void StreamingSettings::Apply()
{
Streaming::TextureGroups = TextureGroups;
}
void StreamingSettings::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
{
DESERIALIZE(TextureGroups);
}
void UpdateResource(StreamableResource* resource, DateTime now)
{
@@ -43,18 +55,18 @@ void UpdateResource(StreamableResource* resource, DateTime now)
auto handler = group->GetHandler();
// Calculate target quality for that asset
StreamingQuality targetQuality = MAX_STREAMING_QUALITY;
float targetQuality = 1.0f;
if (resource->IsDynamic())
{
targetQuality = handler->CalculateTargetQuality(resource, now);
// TODO: here we should apply resources group master scale (based on game settings quality level and memory level)
targetQuality = Math::Clamp<StreamingQuality>(targetQuality, MIN_STREAMING_QUALITY, MAX_STREAMING_QUALITY);
targetQuality = Math::Saturate(targetQuality);
}
// Update quality smoothing
resource->Streaming.QualitySamples.Add(targetQuality);
targetQuality = resource->Streaming.QualitySamples.Maximum();
targetQuality = Math::Clamp<StreamingQuality>(targetQuality, MIN_STREAMING_QUALITY, MAX_STREAMING_QUALITY);
targetQuality = Math::Saturate(targetQuality);
// Calculate target residency level (discrete value)
auto maxResidency = resource->GetMaxResidency();
@@ -132,7 +144,7 @@ void StreamingManagerService::Update()
// Check if skip update
auto now = DateTime::NowUTC();
auto delta = now - LastUpdateTime;
int32 resourcesCount = StreamingManager::Resources.ResourcesCount();
int32 resourcesCount = Streaming::Resources.ResourcesCount();
if (resourcesCount == 0 || delta < ManagerUpdatesInterval || GPUDevice::Instance->GetState() != GPUDevice::DeviceState::Ready)
return;
LastUpdateTime = now;
@@ -154,7 +166,7 @@ void StreamingManagerService::Update()
LastUpdateResourcesIndex = 0;
// Peek resource
const auto resource = StreamingManager::Resources[LastUpdateResourcesIndex];
const auto resource = Streaming::Resources[LastUpdateResourcesIndex];
// Try to update it
if (now - resource->Streaming.LastUpdate >= ResourceUpdatesInterval && resource->CanBeUpdated())

25
Source/Engine/Streaming/Streaming.h Normal file
View File

@@ -0,0 +1,25 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Scripting/ScriptingType.h"
#include "TextureGroup.h"
#include "StreamableResourcesCollection.h"
/// <summary>
/// The content streaming service.
/// </summary>
API_CLASS(Static) class FLAXENGINE_API Streaming
{
DECLARE_SCRIPTING_TYPE_NO_SPAWN(Streaming);
/// <summary>
/// List with all resources
/// </summary>
static StreamableResourcesCollection Resources;
/// <summary>
/// Textures streaming configuration (per-group).
/// </summary>
API_FIELD() static Array<TextureGroup, InlinedAllocation<32>> TextureGroups;
};

5
Source/Engine/Streaming/StreamingGroup.cpp
View File

@@ -1,10 +1,7 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "StreamingGroup.h"
#include "Handlers/TexturesStreamingHandler.h"
#include "Handlers/ModelsStreamingHandler.h"
#include "Handlers/SkinnedModelsStreamingHandler.h"
#include "Handlers/AudioStreamingHandler.h"
#include "StreamingHandlers.h"
StreamingGroup::StreamingGroup(Type type, IStreamingHandler* handler)
: _type(type)

230
Source/Engine/Streaming/StreamingHandlers.cpp Normal file
View File

@@ -0,0 +1,230 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "StreamingHandlers.h"
#include "Streaming.h"
#include "Engine/Core/Math/Math.h"
#include "Engine/Graphics/Textures/StreamingTexture.h"
#include "Engine/Content/Assets/Model.h"
#include "Engine/Content/Assets/SkinnedModel.h"
#include "Engine/Audio/AudioClip.h"
#include "Engine/Audio/Audio.h"
#include "Engine/Audio/AudioSource.h"
float TexturesStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
const TextureHeader& header = *texture.GetHeader();
if (header.TextureGroup < 0 || header.TextureGroup >= Streaming::TextureGroups.Count())
{
// Full texture load by default
return 1.0f;
}
// Quality based on texture group settings
const TextureGroup& group = Streaming::TextureGroups[header.TextureGroup];
return group.QualityScale;
}
int32 TexturesStreamingHandler::CalculateResidency(StreamableResource* resource, float quality)
{
if (quality < ZeroTolerance)
return 0;
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
ASSERT(texture.IsInitialized());
const TextureHeader& header = *texture.GetHeader();
const int32 totalMipLevels = texture.TotalMipLevels();
int32 mipLevels = Math::CeilToInt(quality * (float)totalMipLevels);
if (header.TextureGroup >= 0 && header.TextureGroup < Streaming::TextureGroups.Count())
{
const TextureGroup& group = Streaming::TextureGroups[header.TextureGroup];
mipLevels = Math::Clamp(mipLevels + group.MipLevelsBias, group.MipLevelsMin, group.MipLevelsMax);
#if USE_EDITOR
// Simulate per-platform limit in Editor
int32 max;
if (group.MipLevelsMaxPerPlatform.TryGet(PLATFORM_TYPE, max))
mipLevels = Math::Min(mipLevels, max);
#endif
}
if (mipLevels > 0 && mipLevels < 3 && totalMipLevels > 1 && texture.IsBlockCompressed())
{
// Block compressed textures require minimum size of 4 (3 mips or more)
mipLevels = 3;
}
return Math::Clamp(mipLevels, 0, totalMipLevels);
}
int32 TexturesStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& texture = *(StreamingTexture*)resource;
ASSERT(texture.IsInitialized());
int32 residency = targetResidency;
int32 currentResidency = texture.GetCurrentResidency();
if (currentResidency < targetResidency)
{
// Up
residency = Math::Min(currentResidency + 2, targetResidency);
// Stream first a few mips very fast (they are very small)
const int32 QuickStartMipsCount = 6;
if (currentResidency == 0)
{
residency = Math::Min(QuickStartMipsCount, targetResidency);
}
}
else if (currentResidency > targetResidency)
{
// Down at once
residency = targetResidency;
}
return residency;
}
float ModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
// TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
return 1.0f;
}
int32 ModelsStreamingHandler::CalculateResidency(StreamableResource* resource, float quality)
{
if (quality < ZeroTolerance)
return 0;
ASSERT(resource);
auto& model = *(Model*)resource;
const int32 lodCount = model.GetLODsCount();
int32 lods = Math::CeilToInt(quality * (float)lodCount);
ASSERT(model.IsValidLODIndex(lods - 1));
return lods;
}
int32 ModelsStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& model = *(Model*)resource;
// Always load only single LOD at once
int32 residency = targetResidency;
int32 currentResidency = model.GetCurrentResidency();
if (currentResidency < targetResidency)
{
// Up
residency = currentResidency + 1;
}
else if (currentResidency > targetResidency)
{
// Down
residency = currentResidency - 1;
}
return residency;
}
float SkinnedModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
// TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
return 1.0f;
}
int32 SkinnedModelsStreamingHandler::CalculateResidency(StreamableResource* resource, float quality)
{
if (quality < ZeroTolerance)
return 0;
ASSERT(resource);
auto& model = *(SkinnedModel*)resource;
const int32 lodCount = model.GetLODsCount();
int32 lods = Math::CeilToInt(quality * (float)lodCount);
ASSERT(model.IsValidLODIndex(lods - 1));
return lods;
}
int32 SkinnedModelsStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
ASSERT(resource);
auto& model = *(SkinnedModel*)resource;
// Always load only single LOD at once
int32 residency = targetResidency;
int32 currentResidency = model.GetCurrentResidency();
if (currentResidency < targetResidency)
{
// Up
residency = currentResidency + 1;
}
else if (currentResidency > targetResidency)
{
// Down
residency = currentResidency - 1;
}
return residency;
}
float AudioStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now)
{
// Audio clips don't use quality but only residency
return 1.0f;
}
int32 AudioStreamingHandler::CalculateResidency(StreamableResource* resource, float quality)
{
ASSERT(resource);
auto clip = static_cast<AudioClip*>(resource);
const int32 chunksCount = clip->Buffers.Count();
bool chunksMask[ASSET_FILE_DATA_CHUNKS];
Platform::MemoryClear(chunksMask, sizeof(chunksMask));
// Find audio chunks required for streaming
clip->StreamingQueue.Clear();
for (int32 sourceIndex = 0; sourceIndex < Audio::Sources.Count(); sourceIndex++)
{
// TODO: collect refs to audio clip from sources and use faster iteration (but do it thread-safe)
const auto src = Audio::Sources[sourceIndex];
if (src->Clip == clip && src->GetState() == AudioSource::States::Playing)
{
// Stream the current and the next chunk if could be used in a while
const int32 chunk = src->_streamingFirstChunk;
ASSERT(Math::IsInRange(chunk, 0, chunksCount));
chunksMask[chunk] = true;
const float StreamingDstSec = 2.0f;
if (chunk + 1 < chunksCount && src->GetTime() + StreamingDstSec >= clip->GetBufferStartTime(src->_streamingFirstChunk))
{
chunksMask[chunk + 1] = true;
}
}
}
// Try to enqueue chunks to modify (load or unload)
for (int32 i = 0; i < chunksCount; i++)
{
if (chunksMask[i] != (clip->Buffers[i] != 0))
{
clip->StreamingQueue.Add(i);
}
}
return clip->StreamingQueue.Count();
}
int32 AudioStreamingHandler::CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency)
{
// No smoothing or slowdown in residency change
return targetResidency;
}
bool AudioStreamingHandler::RequiresStreaming(StreamableResource* resource, int32 currentResidency, int32 targetResidency)
{
// Audio clips use streaming queue buffer to detect streaming request start
const auto clip = static_cast<AudioClip*>(resource);
return clip->StreamingQueue.HasItems();
}

54
Source/Engine/Streaming/StreamingHandlers.h Normal file
View File

@@ -0,0 +1,54 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Streaming/IStreamingHandler.h"
/// <summary>
/// Implementation of IStreamingHandler for streamable textures.
/// </summary>
class FLAXENGINE_API TexturesStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
float CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, float quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};
/// <summary>
/// Implementation of IStreamingHandler for streamable models.
/// </summary>
class FLAXENGINE_API ModelsStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
float CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, float quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};
/// <summary>
/// Implementation of IStreamingHandler for streamable skinned models.
/// </summary>
class FLAXENGINE_API SkinnedModelsStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
float CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, float quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
};
/// <summary>
/// Implementation of IStreamingHandler for audio clips.
/// </summary>
class FLAXENGINE_API AudioStreamingHandler : public IStreamingHandler
{
public:
// [IStreamingHandler]
float CalculateTargetQuality(StreamableResource* resource, DateTime now) override;
int32 CalculateResidency(StreamableResource* resource, float quality) override;
int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
bool RequiresStreaming(StreamableResource* resource, int32 currentResidency, int32 targetResidency) override;
};

18
Source/Engine/Streaming/StreamingManager.h
View File

@@ -1,18 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "StreamableResourcesCollection.h"
/// <summary>
/// Main class for dynamic resources streaming service
/// </summary>
class FLAXENGINE_API StreamingManager
{
public:
/// <summary>
/// List with all resources
/// </summary>
static StreamableResourcesCollection Resources;
};

32
Source/Engine/Streaming/StreamingSettings.h Normal file
View File

@@ -0,0 +1,32 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Core/Config/Settings.h"
#include "TextureGroup.h"
/// <summary>
/// Content streaming settings.
/// </summary>
API_CLASS(sealed, Namespace="FlaxEditor.Content.Settings", NoConstructor) class FLAXENGINE_API StreamingSettings : public SettingsBase
{
DECLARE_SCRIPTING_TYPE_MINIMAL(StreamingSettings);
public:
/// <summary>
/// Textures streaming configuration (per-group).
/// </summary>
API_FIELD(Attributes="EditorOrder(100), EditorDisplay(\"Textures\")")
Array<TextureGroup, InlinedAllocation<32>> TextureGroups;
public:
/// <summary>
/// Gets the instance of the settings asset (default value if missing). Object returned by this method is always loaded with valid data to use.
/// </summary>
static StreamingSettings* Get();
// [SettingsBase]
void Apply() override;
void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) final override;
};

56
Source/Engine/Streaming/TextureGroup.h Normal file
View File

@@ -0,0 +1,56 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Engine/Core/Types/String.h"
#include "Engine/Core/ISerializable.h"
#if USE_EDITOR
#include "Engine/Core/Collections/Dictionary.h"
#endif
/// <summary>
/// Settings container for a group of textures. Defines the data streaming options and resource quality.
/// </summary>
API_STRUCT() struct TextureGroup : ISerializable
{
API_AUTO_SERIALIZATION();
DECLARE_SCRIPTING_TYPE_MINIMAL(TextureGroup);
/// <summary>
/// The name of the group.
/// </summary>
API_FIELD(Attributes="EditorOrder(10)")
String Name;
/// <summary>
/// The quality scale factor applied to textures in this group. Can be used to increase or decrease textures resolution. In range 0-1 where 0 means lowest quality, 1 means full quality.
/// </summary>
API_FIELD(Attributes="EditorOrder(20), Limit(0, 1)")
float QualityScale = 1.0f;
/// <summary>
/// The minimum amount of loaded mip levels for textures in this group. Defines the amount of the mips that should be always loaded. Higher values decrease streaming usage and keep more mips loaded.
/// </summary>
API_FIELD(Attributes="EditorOrder(30), Limit(0, 14)")
int32 MipLevelsMin = 0;
/// <summary>
/// The maximum amount of loaded mip levels for textures in this group. Defines the maximum amount of the mips that can be loaded. Overriden per-platform. Lower values reduce textures quality and improve performance.
/// </summary>
API_FIELD(Attributes="EditorOrder(40), Limit(1, 14)")
int32 MipLevelsMax = 14;
/// <summary>
/// The loaded mip levels bias for textures in this group. Can be used to increase or decrease quality of the streaming for textures in this group (eg. bump up the quality during cinematic sequence).
/// </summary>
API_FIELD(Attributes="EditorOrder(50), Limit(-14, 14)")
int32 MipLevelsBias = 0;
#if USE_EDITOR
/// <summary>
/// The per-platform maximum amount of mip levels for textures in this group. Can be used to strip textures quality when cooking game for a target platform.
/// </summary>
API_FIELD(Attributes="EditorOrder(50)")
Dictionary<PlatformType, int32> MipLevelsMaxPerPlatform;
#endif
};

5
Source/Engine/Tools/TextureTool/TextureTool.cpp
View File

@@ -35,6 +35,7 @@ TextureTool::Options::Options()
Resize = false;
PreserveAlphaCoverage = false;
PreserveAlphaCoverageReference = 0.5f;
TextureGroup = -1;
Scale = 1.0f;
SizeX = 1024;
SizeY = 1024;
@@ -97,6 +98,9 @@ void TextureTool::Options::Serialize(SerializeStream& stream, const void* otherO
stream.JKEY("PreserveAlphaCoverageReference");
stream.Float(PreserveAlphaCoverageReference);
stream.JKEY("TextureGroup");
stream.Int(TextureGroup);
stream.JKEY("Scale");
stream.Float(Scale);
@@ -145,6 +149,7 @@ void TextureTool::Options::Deserialize(DeserializeStream& stream, ISerializeModi
Resize = JsonTools::GetBool(stream, "Resize", Resize);
PreserveAlphaCoverage = JsonTools::GetBool(stream, "PreserveAlphaCoverage", PreserveAlphaCoverage);
PreserveAlphaCoverageReference = JsonTools::GetFloat(stream, "PreserveAlphaCoverageReference", PreserveAlphaCoverageReference);
TextureGroup = JsonTools::GetInt(stream, "TextureGroup", TextureGroup);
Scale = JsonTools::GetFloat(stream, "Scale", Scale);
SizeX = JsonTools::GetInt(stream, "SizeX", SizeX);
SizeY = JsonTools::GetInt(stream, "SizeY", SizeY);

5
Source/Engine/Tools/TextureTool/TextureTool.h
View File

@@ -78,6 +78,11 @@ public:
/// </summary>
float PreserveAlphaCoverageReference;
/// <summary>
/// Texture group for streaming (negative if unused). See Streaming Settings.
/// </summary>
int32 TextureGroup;
/// <summary>
/// The import texture scale.
/// </summary>