diff --git a/SDK/include/NDK/LuaAPI.inl b/SDK/include/NDK/LuaAPI.inl index f4d780386..d80652780 100644 --- a/SDK/include/NDK/LuaAPI.inl +++ b/SDK/include/NDK/LuaAPI.inl @@ -64,6 +64,33 @@ namespace Nz return ret; } + inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, FontRef* fontRef, TypeTag) + { + *fontRef = *(*static_cast(instance.CheckUserdata(index, "Font"))); + + return 1; + } + + inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, FontParams* params, TypeTag) + { + instance.CheckType(index, Nz::LuaType_Table); + + return 1; + } + + inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, MeshParams* params, TypeTag) + { + instance.CheckType(index, Nz::LuaType_Table); + + params->animated = instance.CheckField("Animated", params->animated); + params->center = instance.CheckField("Center", params->center); + params->flipUVs = instance.CheckField("FlipUVs", params->flipUVs); + params->optimizeIndexBuffers = instance.CheckField("OptimizeIndexBuffers", params->optimizeIndexBuffers); + params->scale = instance.CheckField("Scale", params->scale); + + return 1; + } + inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Quaterniond* quat, TypeTag) { switch (instance.GetType(index)) @@ -209,19 +236,6 @@ namespace Nz return 1; } - inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, MeshParams* params, TypeTag) - { - instance.CheckType(index, Nz::LuaType_Table); - - params->animated = instance.CheckField("Animated", params->animated); - params->center = instance.CheckField("Center", params->center); - params->flipUVs = instance.CheckField("FlipUVs", params->flipUVs); - params->optimizeIndexBuffers = instance.CheckField("OptimizeIndexBuffers", params->optimizeIndexBuffers); - params->scale = instance.CheckField("Scale", params->scale); - - return 1; - } - inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, ModelParameters* params, TypeTag) { instance.CheckType(index, Nz::LuaType_Table); @@ -267,6 +281,23 @@ namespace Nz return 1; } + inline int LuaImplReplyVal(const LuaInstance& instance, FontRef val, TypeTag) + { + instance.PushInstance("Font", val); + return 1; + } + + inline int LuaImplReplyVal(const LuaInstance& instance, Font::SizeInfo val, TypeTag) + { + instance.PushTable(); + instance.PushField("LineHeight", val.lineHeight); + instance.PushField("SpaceAdvance", val.spaceAdvance); + instance.PushField("UnderlinePosition", val.underlinePosition); + instance.PushField("UnderlineThickness", val.underlineThickness); + + return 1; + } + inline int LuaImplReplyVal(const LuaInstance& instance, Quaterniond val, TypeTag) { instance.PushInstance("Quaternion", val); diff --git a/SDK/include/NDK/LuaBinding.hpp b/SDK/include/NDK/LuaBinding.hpp index a0e3e7719..66bb88978 100644 --- a/SDK/include/NDK/LuaBinding.hpp +++ b/SDK/include/NDK/LuaBinding.hpp @@ -78,6 +78,7 @@ namespace Ndk // Utility Nz::LuaClass abstractImage; + Nz::LuaClass fontClass; Nz::LuaClass nodeClass; // SDK diff --git a/SDK/src/NDK/Console.cpp b/SDK/src/NDK/Console.cpp index 31586d346..24a5d8df2 100644 --- a/SDK/src/NDK/Console.cpp +++ b/SDK/src/NDK/Console.cpp @@ -186,6 +186,12 @@ namespace Ndk void Console::SetTextFont(Nz::FontRef font) { + NazaraAssert(font && font->IsValid(), "Invalid font"); + + m_defaultFont = std::move(font); + m_historyDrawer.SetFont(m_defaultFont); + m_inputDrawer.SetFont(m_defaultFont); + Layout(); } diff --git a/SDK/src/NDK/LuaBinding.cpp b/SDK/src/NDK/LuaBinding.cpp index ab99eb101..a23311075 100644 --- a/SDK/src/NDK/LuaBinding.cpp +++ b/SDK/src/NDK/LuaBinding.cpp @@ -23,6 +23,7 @@ namespace Ndk // Utility abstractImage("AbstractImage"), + fontClass("Font"), nodeClass("Node"), // SDK diff --git a/SDK/src/NDK/LuaBinding_Core.cpp b/SDK/src/NDK/LuaBinding_Core.cpp index a4676284e..16e8f66f6 100644 --- a/SDK/src/NDK/LuaBinding_Core.cpp +++ b/SDK/src/NDK/LuaBinding_Core.cpp @@ -141,7 +141,11 @@ namespace Ndk return new Nz::File(lua.Check(&argIndex)); case 2: - return new Nz::File(lua.Check(&argIndex), lua.Check(&argIndex)); + { + Nz::String filePath = lua.Check(&argIndex); + Nz::UInt32 openMode = lua.Check(&argIndex); + return new Nz::File(filePath, openMode); + } } return nullptr; @@ -189,7 +193,11 @@ namespace Ndk return lua.Push(file.Open(lua.Check(&argIndex, Nz::OpenMode_NotOpen))); case 2: - return lua.Push(file.Open(lua.Check(&argIndex), lua.Check(&argIndex, Nz::OpenMode_NotOpen))); + { + Nz::String filePath = lua.Check(&argIndex); + Nz::UInt32 openMode = lua.Check(&argIndex, Nz::OpenMode_NotOpen); + return lua.Push(file.Open(filePath, openMode)); + } } lua.Error("No matching overload for method Open"); @@ -207,7 +215,11 @@ namespace Ndk return lua.Push(file.SetCursorPos(lua.Check(&argIndex))); case 2: - return lua.Push(file.SetCursorPos(lua.Check(&argIndex), lua.Check(&argIndex))); + { + Nz::CursorPosition curPos = lua.Check(&argIndex); + Nz::Int64 offset = lua.Check(&argIndex); + return lua.Push(file.SetCursorPos(curPos, offset)); + } } lua.Error("No matching overload for method SetCursorPos"); @@ -240,9 +252,9 @@ namespace Ndk static_assert(Nz::CursorPosition_Max + 1 == 3, "Nz::CursorPosition has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 3); { - instance.SetField("AtBegin", Nz::CursorPosition_AtBegin); - instance.SetField("AtCurrent", Nz::CursorPosition_AtCurrent); - instance.SetField("AtEnd", Nz::CursorPosition_AtEnd); + instance.PushField("AtBegin", Nz::CursorPosition_AtBegin); + instance.PushField("AtCurrent", Nz::CursorPosition_AtCurrent); + instance.PushField("AtEnd", Nz::CursorPosition_AtEnd); } instance.SetGlobal("CursorPosition"); @@ -250,15 +262,15 @@ namespace Ndk static_assert(Nz::HashType_Max + 1 == 9, "Nz::HashType has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 9); { - instance.SetField("CRC32", Nz::HashType_CRC32); - instance.SetField("Fletcher16", Nz::HashType_Fletcher16); - instance.SetField("MD5", Nz::HashType_MD5); - instance.SetField("SHA1", Nz::HashType_SHA1); - instance.SetField("SHA224", Nz::HashType_SHA224); - instance.SetField("SHA256", Nz::HashType_SHA256); - instance.SetField("SHA384", Nz::HashType_SHA384); - instance.SetField("SHA512", Nz::HashType_SHA512); - instance.SetField("Whirlpool", Nz::HashType_Whirlpool); + instance.PushField("CRC32", Nz::HashType_CRC32); + instance.PushField("Fletcher16", Nz::HashType_Fletcher16); + instance.PushField("MD5", Nz::HashType_MD5); + instance.PushField("SHA1", Nz::HashType_SHA1); + instance.PushField("SHA224", Nz::HashType_SHA224); + instance.PushField("SHA256", Nz::HashType_SHA256); + instance.PushField("SHA384", Nz::HashType_SHA384); + instance.PushField("SHA512", Nz::HashType_SHA512); + instance.PushField("Whirlpool", Nz::HashType_Whirlpool); } instance.SetGlobal("HashType"); @@ -266,14 +278,14 @@ namespace Ndk static_assert(Nz::OpenMode_Max + 1 == 2 * (64), "Nz::OpenModeFlags has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 8); { - instance.SetField("Append", Nz::OpenMode_Append); - instance.SetField("NotOpen", Nz::OpenMode_NotOpen); - instance.SetField("Lock", Nz::OpenMode_Lock); - instance.SetField("ReadOnly", Nz::OpenMode_ReadOnly); - instance.SetField("ReadWrite", Nz::OpenMode_ReadWrite); - instance.SetField("Text", Nz::OpenMode_Text); - instance.SetField("Truncate", Nz::OpenMode_Truncate); - instance.SetField("WriteOnly", Nz::OpenMode_WriteOnly); + instance.PushField("Append", Nz::OpenMode_Append); + instance.PushField("NotOpen", Nz::OpenMode_NotOpen); + instance.PushField("Lock", Nz::OpenMode_Lock); + instance.PushField("ReadOnly", Nz::OpenMode_ReadOnly); + instance.PushField("ReadWrite", Nz::OpenMode_ReadWrite); + instance.PushField("Text", Nz::OpenMode_Text); + instance.PushField("Truncate", Nz::OpenMode_Truncate); + instance.PushField("WriteOnly", Nz::OpenMode_WriteOnly); } instance.SetGlobal("OpenMode"); } diff --git a/SDK/src/NDK/LuaBinding_Network.cpp b/SDK/src/NDK/LuaBinding_Network.cpp index 4b8334017..e7673b86c 100644 --- a/SDK/src/NDK/LuaBinding_Network.cpp +++ b/SDK/src/NDK/LuaBinding_Network.cpp @@ -90,10 +90,10 @@ namespace Ndk { instance.PushInteger(index++); instance.PushTable(0, 4); - instance.SetField("Address", std::move(info.address)); - instance.SetField("CanonicalName", std::move(info.canonicalName)); - instance.SetField("Protocol", std::move(info.protocol)); - instance.SetField("SocketType", std::move(info.socketType)); + instance.PushField("Address", std::move(info.address)); + instance.PushField("CanonicalName", std::move(info.canonicalName)); + instance.PushField("Protocol", std::move(info.protocol)); + instance.PushField("SocketType", std::move(info.socketType)); instance.SetTable(); } @@ -120,10 +120,10 @@ namespace Ndk static_assert(Nz::NetProtocol_Max + 1 == 4, "Nz::NetProtocol has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 4); { - instance.SetField("Any", Nz::NetProtocol_Any); - instance.SetField("IPv4", Nz::NetProtocol_IPv4); - instance.SetField("IPv6", Nz::NetProtocol_IPv6); - instance.SetField("Unknown", Nz::NetProtocol_Unknown); + instance.PushField("Any", Nz::NetProtocol_Any); + instance.PushField("IPv4", Nz::NetProtocol_IPv4); + instance.PushField("IPv6", Nz::NetProtocol_IPv6); + instance.PushField("Unknown", Nz::NetProtocol_Unknown); } instance.SetGlobal("NetProtocol"); @@ -131,12 +131,12 @@ namespace Ndk static_assert(Nz::PacketPriority_Max + 1 == 4, "Nz::PacketPriority has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 6); { - instance.SetField("High", Nz::PacketPriority_High); - instance.SetField("Highest", Nz::PacketPriority_Highest); - instance.SetField("Immediate", Nz::PacketPriority_Immediate); - instance.SetField("Medium", Nz::PacketPriority_Medium); - instance.SetField("Low", Nz::PacketPriority_Low); - instance.SetField("Lowest", Nz::PacketPriority_Lowest); + instance.PushField("High", Nz::PacketPriority_High); + instance.PushField("Highest", Nz::PacketPriority_Highest); + instance.PushField("Immediate", Nz::PacketPriority_Immediate); + instance.PushField("Medium", Nz::PacketPriority_Medium); + instance.PushField("Low", Nz::PacketPriority_Low); + instance.PushField("Lowest", Nz::PacketPriority_Lowest); } instance.SetGlobal("PacketPriority"); @@ -144,9 +144,9 @@ namespace Ndk static_assert(Nz::PacketReliability_Max + 1 == 3, "Nz::PacketReliability has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 3); { - instance.SetField("Reliable", Nz::PacketReliability_Reliable); - instance.SetField("ReliableOrdered", Nz::PacketReliability_ReliableOrdered); - instance.SetField("Unreliable", Nz::PacketReliability_Unreliable); + instance.PushField("Reliable", Nz::PacketReliability_Reliable); + instance.PushField("ReliableOrdered", Nz::PacketReliability_ReliableOrdered); + instance.PushField("Unreliable", Nz::PacketReliability_Unreliable); } instance.SetGlobal("PacketReliability"); @@ -154,15 +154,15 @@ namespace Ndk static_assert(Nz::ResolveError_Max + 1 == 9, "Nz::ResolveError has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 9); { - instance.SetField("Internal", Nz::ResolveError_Internal); - instance.SetField("ResourceError", Nz::ResolveError_ResourceError); - instance.SetField("NoError", Nz::ResolveError_NoError); - instance.SetField("NonRecoverable", Nz::ResolveError_NonRecoverable); - instance.SetField("NotFound", Nz::ResolveError_NotFound); - instance.SetField("NotInitialized", Nz::ResolveError_NotInitialized); - instance.SetField("ProtocolNotSupported", Nz::ResolveError_ProtocolNotSupported); - instance.SetField("TemporaryFailure", Nz::ResolveError_TemporaryFailure); - instance.SetField("Unknown", Nz::ResolveError_Unknown); + instance.PushField("Internal", Nz::ResolveError_Internal); + instance.PushField("ResourceError", Nz::ResolveError_ResourceError); + instance.PushField("NoError", Nz::ResolveError_NoError); + instance.PushField("NonRecoverable", Nz::ResolveError_NonRecoverable); + instance.PushField("NotFound", Nz::ResolveError_NotFound); + instance.PushField("NotInitialized", Nz::ResolveError_NotInitialized); + instance.PushField("ProtocolNotSupported", Nz::ResolveError_ProtocolNotSupported); + instance.PushField("TemporaryFailure", Nz::ResolveError_TemporaryFailure); + instance.PushField("Unknown", Nz::ResolveError_Unknown); } instance.SetGlobal("ResolveError"); @@ -170,21 +170,21 @@ namespace Ndk static_assert(Nz::SocketError_Max + 1 == 15, "Nz::ResolveError has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 15); { - instance.SetField("AddressNotAvailable", Nz::SocketError_AddressNotAvailable); - instance.SetField("ConnectionClosed", Nz::SocketError_ConnectionClosed); - instance.SetField("ConnectionRefused", Nz::SocketError_ConnectionRefused); - instance.SetField("DatagramSize", Nz::SocketError_DatagramSize); - instance.SetField("Internal", Nz::SocketError_Internal); - instance.SetField("Packet", Nz::SocketError_Packet); - instance.SetField("NetworkError", Nz::SocketError_NetworkError); - instance.SetField("NoError", Nz::SocketError_NoError); - instance.SetField("NotInitialized", Nz::SocketError_NotInitialized); - instance.SetField("NotSupported", Nz::SocketError_NotSupported); - instance.SetField("ResolveError", Nz::SocketError_ResolveError); - instance.SetField("ResourceError", Nz::SocketError_ResourceError); - instance.SetField("TimedOut", Nz::SocketError_TimedOut); - instance.SetField("Unknown", Nz::SocketError_Unknown); - instance.SetField("UnreachableHost", Nz::SocketError_UnreachableHost); + instance.PushField("AddressNotAvailable", Nz::SocketError_AddressNotAvailable); + instance.PushField("ConnectionClosed", Nz::SocketError_ConnectionClosed); + instance.PushField("ConnectionRefused", Nz::SocketError_ConnectionRefused); + instance.PushField("DatagramSize", Nz::SocketError_DatagramSize); + instance.PushField("Internal", Nz::SocketError_Internal); + instance.PushField("Packet", Nz::SocketError_Packet); + instance.PushField("NetworkError", Nz::SocketError_NetworkError); + instance.PushField("NoError", Nz::SocketError_NoError); + instance.PushField("NotInitialized", Nz::SocketError_NotInitialized); + instance.PushField("NotSupported", Nz::SocketError_NotSupported); + instance.PushField("ResolveError", Nz::SocketError_ResolveError); + instance.PushField("ResourceError", Nz::SocketError_ResourceError); + instance.PushField("TimedOut", Nz::SocketError_TimedOut); + instance.PushField("Unknown", Nz::SocketError_Unknown); + instance.PushField("UnreachableHost", Nz::SocketError_UnreachableHost); } instance.SetGlobal("SocketError"); @@ -192,11 +192,11 @@ namespace Ndk static_assert(Nz::SocketState_Max + 1 == 5, "Nz::SocketState has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 5); { - instance.SetField("Bound", Nz::SocketState_Bound); - instance.SetField("Connecting", Nz::SocketState_Connecting); - instance.SetField("Connected", Nz::SocketState_Connected); - instance.SetField("NotConnected", Nz::SocketState_NotConnected); - instance.SetField("Resolving", Nz::SocketState_Resolving); + instance.PushField("Bound", Nz::SocketState_Bound); + instance.PushField("Connecting", Nz::SocketState_Connecting); + instance.PushField("Connected", Nz::SocketState_Connected); + instance.PushField("NotConnected", Nz::SocketState_NotConnected); + instance.PushField("Resolving", Nz::SocketState_Resolving); } instance.SetGlobal("SocketState"); @@ -204,10 +204,10 @@ namespace Ndk static_assert(Nz::SocketType_Max + 1 == 4, "Nz::SocketState has been updated but change was not reflected to Lua binding"); instance.PushTable(0, 4); { - instance.SetField("Raw", Nz::SocketType_Raw); - instance.SetField("TCP", Nz::SocketType_TCP); - instance.SetField("UDP", Nz::SocketType_UDP); - instance.SetField("Unknown", Nz::SocketType_Unknown); + instance.PushField("Raw", Nz::SocketType_Raw); + instance.PushField("TCP", Nz::SocketType_TCP); + instance.PushField("UDP", Nz::SocketType_UDP); + instance.PushField("Unknown", Nz::SocketType_Unknown); } instance.SetGlobal("SocketType"); } diff --git a/SDK/src/NDK/LuaBinding_SDK.cpp b/SDK/src/NDK/LuaBinding_SDK.cpp index 7f020934d..289e316a3 100644 --- a/SDK/src/NDK/LuaBinding_SDK.cpp +++ b/SDK/src/NDK/LuaBinding_SDK.cpp @@ -38,7 +38,7 @@ namespace Ndk consoleClass.BindMethod("GetInput", &Console::GetInput); consoleClass.BindMethod("GetInputBackground", &Console::GetInputBackground); consoleClass.BindMethod("GetSize", &Console::GetSize); - //consoleClass.SetMethod("GetTextFont", &Console::GetTextFont); + consoleClass.BindMethod("GetTextFont", &Console::GetTextFont); consoleClass.BindMethod("IsVisible", &Console::IsVisible); @@ -47,7 +47,7 @@ namespace Ndk consoleClass.BindMethod("SetCharacterSize", &Console::SetCharacterSize); consoleClass.BindMethod("SetSize", &Console::SetSize); - //consoleClass.SetMethod("SetTextFont", &Console::SetTextFont); + consoleClass.BindMethod("SetTextFont", &Console::SetTextFont); consoleClass.BindMethod("Show", &Console::Show, true); #endif @@ -194,8 +194,7 @@ namespace Ndk if (entry.name.IsEmpty()) continue; - instance.PushInteger(entry.index); - instance.SetField(entry.name); + instance.PushField(entry.name, entry.index); } } instance.SetGlobal("ComponentType"); diff --git a/SDK/src/NDK/LuaBinding_Utility.cpp b/SDK/src/NDK/LuaBinding_Utility.cpp index 86f4a6f9a..8ffa7824d 100644 --- a/SDK/src/NDK/LuaBinding_Utility.cpp +++ b/SDK/src/NDK/LuaBinding_Utility.cpp @@ -88,6 +88,66 @@ namespace Ndk return 0; }); + /*********************************** Nz::Font **********************************/ + fontClass.SetConstructor([] (Nz::LuaInstance& lua) -> Nz::FontRef* + { + return new Nz::FontRef(new Nz::Font); + }); + + fontClass.BindMethod("ClearGlyphCache", &Nz::Font::ClearGlyphCache); + fontClass.BindMethod("ClearKerningCache", &Nz::Font::ClearKerningCache); + fontClass.BindMethod("ClearSizeInfoCache", &Nz::Font::ClearSizeInfoCache); + + fontClass.BindMethod("Destroy", &Nz::Font::Destroy); + + fontClass.BindMethod("GetCachedGlyphCount", [] (Nz::LuaInstance& lua, Nz::FontRef& instance) -> int + { + unsigned int argCount = std::min(lua.GetStackTop(), 2U); + + int argIndex = 1; + switch (argCount) + { + case 0: + lua.Push(instance->GetCachedGlyphCount()); + return 1; + + case 2: + { + unsigned int characterSize = lua.Check(&argIndex); + Nz::UInt32 style = lua.Check(&argIndex); + + lua.Push(instance->GetCachedGlyphCount(characterSize, style)); + return 1; + } + } + + lua.Error("No matching overload for method GetCachedGlyphCount"); + return 0; + }); + + fontClass.BindMethod("GetFamilyName", &Nz::Font::GetFamilyName); + fontClass.BindMethod("GetKerning", &Nz::Font::GetKerning); + fontClass.BindMethod("GetGlyphBorder", &Nz::Font::GetGlyphBorder); + fontClass.BindMethod("GetMinimumStepSize", &Nz::Font::GetMinimumStepSize); + fontClass.BindMethod("GetSizeInfo", &Nz::Font::GetSizeInfo); + fontClass.BindMethod("GetStyleName", &Nz::Font::GetStyleName); + + fontClass.BindMethod("IsValid", &Nz::Font::IsValid); + + fontClass.BindMethod("Precache", (bool(Nz::Font::*)(unsigned int, Nz::UInt32, const Nz::String&) const) &Nz::Font::Precache); + + fontClass.BindMethod("OpenFromFile", &Nz::Font::OpenFromFile, Nz::FontParams()); + + fontClass.BindMethod("SetGlyphBorder", &Nz::Font::SetGlyphBorder); + fontClass.BindMethod("SetMinimumStepSize", &Nz::Font::SetMinimumStepSize); + + fontClass.BindStaticMethod("GetDefault", &Nz::Font::GetDefault); + fontClass.BindStaticMethod("GetDefaultGlyphBorder", &Nz::Font::GetDefaultGlyphBorder); + fontClass.BindStaticMethod("GetDefaultMinimumStepSize", &Nz::Font::GetDefaultMinimumStepSize); + + fontClass.BindStaticMethod("SetDefaultGlyphBorder", &Nz::Font::SetDefaultGlyphBorder); + fontClass.BindStaticMethod("SetDefaultMinimumStepSize", &Nz::Font::SetDefaultMinimumStepSize); + /*********************************** Nz::Node **********************************/ nodeClass.BindMethod("GetBackward", &Nz::Node::GetBackward); //nodeClass.SetMethod("GetChilds", &Nz::Node::GetChilds); @@ -250,6 +310,7 @@ namespace Ndk void LuaBinding::RegisterUtility(Nz::LuaInstance& instance) { abstractImage.Register(instance); + fontClass.Register(instance); nodeClass.Register(instance); } } \ No newline at end of file diff --git a/build/scripts/tools/ndk.lua b/build/scripts/tools/ndk.lua index 33c79c3fb..78ff544de 100644 --- a/build/scripts/tools/ndk.lua +++ b/build/scripts/tools/ndk.lua @@ -24,9 +24,10 @@ TOOL.Libraries = { "NazaraCore", "NazaraAudio", "NazaraLua", + "NazaraNetwork", "NazaraNoise", "NazaraPhysics", "NazaraUtility", "NazaraRenderer", - "NazaraGraphics", + "NazaraGraphics" } diff --git a/build/scripts/tools/ndk_server.lua b/build/scripts/tools/ndk_server.lua index 6b6d32941..a309eba9a 100644 --- a/build/scripts/tools/ndk_server.lua +++ b/build/scripts/tools/ndk_server.lua @@ -38,6 +38,7 @@ TOOL.FilesExclusion = { TOOL.Libraries = { "NazaraCore", "NazaraLua", + "NazaraNetwork", "NazaraNoise", "NazaraPhysics", "NazaraUtility" diff --git a/include/Nazara/Lua/LuaInstance.hpp b/include/Nazara/Lua/LuaInstance.hpp index 9dd5c3571..e2d15958f 100644 --- a/include/Nazara/Lua/LuaInstance.hpp +++ b/include/Nazara/Lua/LuaInstance.hpp @@ -125,8 +125,12 @@ namespace Nz template int Push(T arg) const; void PushBoolean(bool value) const; void PushCFunction(LuaCFunction func, unsigned int upvalueCount = 0) const; + template void PushField(const char* name, T&& arg, int tableIndex = -2) const; + template void PushField(const String& name, T&& arg, int tableIndex = -2) const; void PushFunction(LuaFunction func) const; template void PushFunction(R(*func)(Args...), DefArgs&&... defArgs) const; + template void PushGlobal(const char* name, T&& arg); + template void PushGlobal(const String& name, T&& arg); template void PushInstance(const char* tname, T* instance) const; template void PushInstance(const char* tname, Args&&... args) const; void PushInteger(long long value) const; @@ -146,12 +150,8 @@ namespace Nz void Remove(int index) const; void Replace(int index) const; - template void SetField(const char* name, T&& arg, int tableIndex = -2); - template void SetField(const String& name, T&& arg, int tableIndex = -2); - void SetField(const char* name, int tableIndex = -2); - void SetField(const String& name, int tableIndex = -2); - template void SetGlobal(const char* name, T&& arg); - template void SetGlobal(const String& name, T&& arg); + void SetField(const char* name, int tableIndex = -2) const; + void SetField(const String& name, int tableIndex = -2) const; void SetGlobal(const char* name); void SetGlobal(const String& name); void SetMetatable(const char* tname) const; diff --git a/include/Nazara/Lua/LuaInstance.inl b/include/Nazara/Lua/LuaInstance.inl index a445df491..199efa38f 100644 --- a/include/Nazara/Lua/LuaInstance.inl +++ b/include/Nazara/Lua/LuaInstance.inl @@ -144,6 +144,18 @@ namespace Nz return 1; } + template + std::enable_if_t::value || std::is_enum::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag) + { + return LuaImplReplyVal(instance, val, TypeTag()); + } + + template + std::enable_if_t::value || std::is_enum::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag) + { + return LuaImplReplyVal(instance, val, TypeTag()); + } + inline int LuaImplReplyVal(const LuaInstance& instance, std::string val, TypeTag) { instance.PushString(val.c_str(), val.size()); @@ -541,6 +553,19 @@ namespace Nz return LuaImplReplyVal(*this, std::move(arg), TypeTag()); } + template + void LuaInstance::PushField(const char* name, T&& arg, int tableIndex) const + { + Push(std::forward(arg)); + SetField(name, tableIndex); + } + + template + void LuaInstance::PushField(const String& name, T&& arg, int tableIndex) const + { + PushField(name.GetConstBuffer(), std::forward(arg), tableIndex); + } + template void LuaInstance::PushFunction(R(*func)(Args...), DefArgs&&... defArgs) const { @@ -554,6 +579,19 @@ namespace Nz }); } + template + void LuaInstance::PushGlobal(const char* name, T&& arg) + { + Push(std::forward(arg)); + SetGlobal(name); + } + + template + void LuaInstance::PushGlobal(const String& name, T&& arg) + { + PushGlobal(name.GetConstBuffer(), std::forward(arg)); + } + template void LuaInstance::PushInstance(const char* tname, T* instance) const { @@ -568,32 +606,6 @@ namespace Nz PushInstance(tname, new T(std::forward(args)...)); } - template - void LuaInstance::SetField(const char* name, T&& arg, int tableIndex) - { - Push(std::forward(arg)); - SetField(name, tableIndex); - } - - template - void LuaInstance::SetField(const String& name, T&& arg, int tableIndex) - { - SetField(name.GetConstBuffer(), std::forward(arg), tableIndex); - } - - template - void LuaInstance::SetGlobal(const char* name, T&& arg) - { - Push(std::forward(arg)); - SetGlobal(name); - } - - template - void LuaInstance::SetGlobal(const String& name, T&& arg) - { - SetGlobal(name.GetConstBuffer(), std::forward(arg)); - } - template T LuaInstance::CheckBounds(int index, long long value) const { diff --git a/include/Nazara/Utility/Font.hpp b/include/Nazara/Utility/Font.hpp index 58ff341b5..257e91245 100644 --- a/include/Nazara/Utility/Font.hpp +++ b/include/Nazara/Utility/Font.hpp @@ -89,7 +89,7 @@ namespace Nz Font& operator=(Font&&) = delete; static std::shared_ptr GetDefaultAtlas(); - static Font* GetDefault(); + static const FontRef& GetDefault(); static unsigned int GetDefaultGlyphBorder(); static unsigned int GetDefaultMinimumStepSize(); diff --git a/src/Nazara/Lua/LuaInstance.cpp b/src/Nazara/Lua/LuaInstance.cpp index 8e437d759..a93013567 100644 --- a/src/Nazara/Lua/LuaInstance.cpp +++ b/src/Nazara/Lua/LuaInstance.cpp @@ -714,12 +714,12 @@ namespace Nz lua_replace(m_state, index); } - void LuaInstance::SetField(const char* name, int tableIndex) + void LuaInstance::SetField(const char* name, int tableIndex) const { lua_setfield(m_state, tableIndex, name); } - void LuaInstance::SetField(const String& name, int tableIndex) + void LuaInstance::SetField(const String& name, int tableIndex) const { lua_setfield(m_state, tableIndex, name.GetConstBuffer()); } diff --git a/src/Nazara/Utility/Font.cpp b/src/Nazara/Utility/Font.cpp index b7cefb362..9e26d28bb 100644 --- a/src/Nazara/Utility/Font.cpp +++ b/src/Nazara/Utility/Font.cpp @@ -350,7 +350,7 @@ namespace Nz return s_defaultAtlas; } - Font* Font::GetDefault() + const FontRef& Font::GetDefault() { // Nous n'initialisons la police par défaut qu'à la demande pour qu'elle prenne // les paramètres par défaut (qui peuvent avoir étés changés par l'utilisateur),