added texture resolution limiting setting, lua platform helpers

Author: turanszkij

Content/Documentation/ScriptingAPI-Documentation.md

@@ -137,6 +137,14 @@ These are some helpers to aid in debugging:
 - ReturnToEditor()	-- returns control to the editor and kills running scripts
 - IsThisDebugBuild() : bool	-- returns true if this is a debug build, false otherwise
 
+Helpers to determine the current platform, if need to implement specific functionality:
+- IsPlatformWindows() : bool
+- IsPlatformLinux() : bool
+- IsPlatformMACOS() : bool
+- IsPlatformIOS() : bool
+- IsPlatformPS5() : bool
+- IsPlatformXBOX() : bool
+
 ## Engine Bindings
 The scripting API provides functions for the developer to manipulate engine behaviour or query it for information.
 
@@ -518,6 +526,11 @@ A texture image data.
 	float edge_smoothness = 0.04) -- creates a lens distortion normal map (16-bit precision)
 - Save(string filename) -- saves texture into a file. Provide the extension in the filename, it should be one of the following: .JPG, .PNG, .TGA, .BMP, .DDS
 
+- SetTextureResolutionLimit(int resolution) -- Set the highest allowed texture asset resolution (only for DDS textures that contain mipmaps)
+- GetTextureResolutionLimit() : int
+- SetTextureResolutionLimit(float threshold) -- Set threshold relative to memory budget for streaming. If memory usage is below threshold, streaming will work regularly.If memory usage is above threshold, streaming will try to reduce usage
+- GetTextureResolutionLimit() : float
+
 ```lua
 GradientType = {
 	Linear = 0,

WickedEngine/wiLua.cpp

@@ -29,6 +29,7 @@
 #include "wiTimer.h"
 #include "wiVector.h"
 #include "wiVersion.h"
+#include "wiPlatform.h"
 
 #include <memory>
 
@@ -72,6 +73,61 @@ namespace wi::lua
 		return 0;
 	}
 
+	int IsPlatformWindows(lua_State* L)
+	{
+#ifdef PLATFORM_WINDOWS_DESKTOP
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_WINDOWS_DESKTOP
+		return 1;
+	}
+	int IsPlatformLinux(lua_State* L)
+	{
+#ifdef PLATFORM_LINUX
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_LINUX
+		return 1;
+	}
+	int IsPlatformMACOS(lua_State* L)
+	{
+#ifdef PLATFORM_MACOS
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_MACOS
+		return 1;
+	}
+	int IsPlatformIOS(lua_State* L)
+	{
+#ifdef PLATFORM_IOS
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_IOS
+		return 1;
+	}
+	int IsPlatformPS5(lua_State* L)
+	{
+#ifdef PLATFORM_PS5
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_PS5
+		return 1;
+	}
+	int IsPlatformXBOX(lua_State* L)
+	{
+#ifdef PLATFORM_XBOX
+		wi::lua::SSetBool(L, true);
+#else
+		wi::lua::SSetBool(L, false);
+#endif // PLATFORM_XBOX
+		return 1;
+	}
+
 	void PostErrorMsg(lua_State* L)
 	{
 		const char* str = lua_tostring(L, -1);
@@ -289,6 +345,13 @@ namespace wi::lua
 		RegisterFunc("GetCreditsString", GetCreditsString);
 		RegisterFunc("GetSupportersString", GetSupportersString);
 
+		RegisterFunc("IsPlatformWindows", IsPlatformWindows);
+		RegisterFunc("IsPlatformLinux", IsPlatformLinux);
+		RegisterFunc("IsPlatformMACOS", IsPlatformMACOS);
+		RegisterFunc("IsPlatformIOS", IsPlatformIOS);
+		RegisterFunc("IsPlatformPS5", IsPlatformPS5);
+		RegisterFunc("IsPlatformXBOX", IsPlatformXBOX);
+
 		Vector_BindLua::Bind();
 		Matrix_BindLua::Bind();
 		Application_BindLua::Bind();

WickedEngine/wiResourceManager.cpp

@@ -40,6 +40,9 @@ namespace wi
 	//static constexpr size_t streaming_texture_min_size = 4096; // 4KB is the minimum texture memory alignment
 	static constexpr size_t streaming_texture_min_size = 64 * 1024; // 64KB is the usual texture memory alignment, this allows higher base tex size than 4KB
 
+	// Texture resolution limit
+	static uint32_t max_texture_resolution = ~0u;
+
 	struct ResourceInternal
 	{
 		resourcemanager::Flags flags = resourcemanager::Flags::NONE;
@@ -524,7 +527,20 @@ namespace wi
 							}
 						}
 
+
 						int mip_offset = 0;
+
+						// mipmap reduction for resolution limit:
+						while (desc.width > max_texture_resolution && desc.height > max_texture_resolution && desc.mip_levels > 1)
+						{
+							desc.width = std::max(desc.width >> 1, 1u);
+							desc.height = std::max(desc.height >> 1, 1u);
+							desc.depth = std::max(desc.depth >> 1, 1u);
+							desc.mip_levels -= 1;
+							mip_offset++;
+						}
+
+						// mipmap reduction for streaming resources:
 						if (has_flag(flags, Flags::STREAMING))
 						{
 							// Remember full mipcount for streaming:
@@ -543,8 +559,8 @@ namespace wi
 							// Reduce mip map count that will be uploaded to GPU:
 							while (desc.mip_levels > 1 && desc.depth == 1 && desc.array_size == 1 && ComputeTextureMemorySizeInBytes(desc) > streaming_texture_min_size)
 							{
-								desc.width >>= 1;
-								desc.height >>= 1;
+								desc.width = std::max(desc.width >> 1, 1u);
+								desc.height = std::max(desc.height >> 1, 1u);
 								desc.mip_levels -= 1;
 								mip_offset++;
 							}
@@ -1405,6 +1421,15 @@ namespace wi
 			}
 		}
 
+		void SetTextureResolutionLimit(uint32_t resolution)
+		{
+			max_texture_resolution = resolution;
+		}
+		uint32_t GetTextureResolutionLimit()
+		{
+			return max_texture_resolution;
+		}
+
 		void Serialize_READ(wi::Archive& archive, ResourceSerializer& seri)
 		{
 			assert(archive.IsReadMode());

WickedEngine/wiResourceManager.h

@@ -101,6 +101,10 @@ namespace wi
 		// Invalidate all resources
 		void Clear();
 
+		// Set the highest allowed texture asset resolution (only for DDS textures that contain mipmaps)
+		void SetTextureResolutionLimit(uint32_t resolution);
+		uint32_t GetTextureResolutionLimit();
+
 		// Set threshold relative to memory budget for streaming
 		//	If memory usage is below threshold, streaming will work regularly
 		//	If memory usage is above threshold, streaming will try to reduce usage

WickedEngine/wiTerrain.cpp

@@ -23,6 +23,19 @@
 #define NOSPARSE
 #endif // __APPLE__
 
+// Logical texture resolution limits:
+const uint32_t min_virtual_resolution = SVT_TILE_SIZE;
+const uint32_t max_virtual_resolution = 65536u;
+
+#ifdef NOSPARSE
+// Try to account for memory increase in no-sparse mode, reduce atlas size:
+const uint32_t atlas_physical_width = 16384u;
+const uint32_t atlas_physical_height = 8192u;
+#else
+const uint32_t atlas_physical_width = 16384u;
+const uint32_t atlas_physical_height = 16384u;
+#endif // NOSPARSE
+
 using namespace wi::ecs;
 using namespace wi::scene;
 using namespace wi::graphics;
@@ -1570,21 +1583,13 @@ namespace wi::terrain
 
 			if (!atlas.IsValid())
 			{
-#ifdef NOSPARSE
-				// Try to account for memory increase in no-sparse mode, reduce atlas size:
-				const uint32_t physical_width = 16384u;
-				const uint32_t physical_height = 8192u;
-#else
-				const uint32_t physical_width = 16384u;
-				const uint32_t physical_height = 16384u;
-#endif // NOSPARSE
 				GPUBufferDesc tile_pool_desc;
 
 				for (uint32_t map_type = 0; map_type < arraysize(atlas.maps); ++map_type)
 				{
 					TextureDesc desc;
-					desc.width = physical_width;
-					desc.height = physical_height;
+					desc.width = atlas_physical_width;
+					desc.height = atlas_physical_height;
 #ifndef NOSPARSE
 					desc.misc_flags = ResourceMiscFlag::SPARSE;
 #endif // NOSPARSE
@@ -1649,8 +1654,8 @@ namespace wi::terrain
 				assert(success);
 #endif // NOSPARSE
 
-				atlas.physical_tile_count_x = uint8_t(physical_width / SVT_TILE_SIZE_PADDED);
-				atlas.physical_tile_count_y = uint8_t(physical_height / SVT_TILE_SIZE_PADDED);
+				atlas.physical_tile_count_x = uint8_t(atlas_physical_width / SVT_TILE_SIZE_PADDED);
+				atlas.physical_tile_count_y = uint8_t(atlas_physical_height / SVT_TILE_SIZE_PADDED);
 				atlas.physical_tiles.resize(size_t(atlas.physical_tile_count_x) * size_t(atlas.physical_tile_count_y));
 
 				uint64_t init_frames = 0;
@@ -1703,9 +1708,7 @@ namespace wi::terrain
 			}
 			VirtualTexture& vt = *chunk_data.vt;
 
-			const uint32_t min_resolution = SVT_TILE_SIZE;
-			const uint32_t max_resolution = 65536u;
-			const uint32_t required_resolution = dist < 2 ? max_resolution : min_resolution;
+			const uint32_t required_resolution = dist < 2 ? max_virtual_resolution : min_virtual_resolution;
 			//const uint32_t required_resolution = std::max(min_resolution, max_resolution >> std::min(7, std::max(0, dist - 1)));
 
 			if (vt.resolution != required_resolution)

WickedEngine/wiTexture_BindLua.cpp

@@ -250,6 +250,40 @@ namespace wi::lua
 		return 1;
 	}
 
+
+	int SetTextureResolutionLimit(lua_State* L)
+	{
+		int argc = wi::lua::SGetArgCount(L);
+		if (argc < 1)
+		{
+			wi::lua::SError(L, "SetTextureResolutionLimit(int resolution) missing argument!");
+			return 0;
+		}
+		wi::resourcemanager::SetTextureResolutionLimit(wi::lua::SGetInt(L, 1));
+		return 0;
+	}
+	int GetTextureResolutionLimit(lua_State* L)
+	{
+		wi::lua::SSetInt(L, wi::resourcemanager::GetTextureResolutionLimit());
+		return 1;
+	}
+	int SetStreamingMemoryThreshold(lua_State* L)
+	{
+		int argc = wi::lua::SGetArgCount(L);
+		if (argc < 1)
+		{
+			wi::lua::SError(L, "SetStreamingMemoryThreshold(float threshold) missing argument!");
+			return 0;
+		}
+		wi::resourcemanager::SetStreamingMemoryThreshold(wi::lua::SGetFloat(L, 1));
+		return 0;
+	}
+	int GetStreamingMemoryThreshold(lua_State* L)
+	{
+		wi::lua::SSetFloat(L, wi::resourcemanager::GetStreamingMemoryThreshold());
+		return 1;
+	}
+
 	void Texture_BindLua::Bind()
 	{
 		static bool initialized = false;
@@ -258,6 +292,10 @@ namespace wi::lua
 			initialized = true;
 			Luna<Texture_BindLua>::Register(wi::lua::GetLuaState());
 			Luna<Texture_BindLua>::push_global(wi::lua::GetLuaState(), "texturehelper");
+			wi::lua::RegisterFunc("SetTextureResolutionLimit", SetTextureResolutionLimit);
+			wi::lua::RegisterFunc("GetTextureResolutionLimit", GetTextureResolutionLimit);
+			wi::lua::RegisterFunc("SetTextureResolutionLimit", SetTextureResolutionLimit);
+			wi::lua::RegisterFunc("GetTextureResolutionLimit", GetTextureResolutionLimit);
 			wi::lua::RunText(R"(
 GradientType = {
 	Linear = 0,

WickedEngine/wiVersion.cpp

@@ -9,7 +9,7 @@ namespace wi::version
 	// minor features, major updates, breaking compatibility changes
 	const int minor = 72;
 	// minor bug fixes, alterations, refactors, updates
-	const int revision = 73;
+	const int revision = 74;
 
 	const std::string version_string = std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(revision);