Remove Lua and Noise modules
This commit is contained in:
Lynix
@@ -1,40 +0,0 @@
|
||||
// This file was automatically generated
|
||||
|
||||
/*
|
||||
Nazara Engine - Lua scripting module
|
||||
|
||||
Copyright (C) 2015 Jérôme Leclercq (lynix680@gmail.com)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_GLOBAL_LUA_HPP
|
||||
#define NAZARA_GLOBAL_LUA_HPP
|
||||
|
||||
#include <Nazara/Lua/Config.hpp>
|
||||
#include <Nazara/Lua/Enums.hpp>
|
||||
#include <Nazara/Lua/Lua.hpp>
|
||||
#include <Nazara/Lua/LuaClass.hpp>
|
||||
#include <Nazara/Lua/LuaCoroutine.hpp>
|
||||
#include <Nazara/Lua/LuaInstance.hpp>
|
||||
#include <Nazara/Lua/LuaState.hpp>
|
||||
|
||||
#endif // NAZARA_GLOBAL_LUA_HPP
|
||||
@@ -1,51 +0,0 @@
|
||||
/*
|
||||
Nazara Engine - Lua scripting module
|
||||
|
||||
Copyright (C) 2015 Jérôme Leclercq (lynix680@gmail.com)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_CONFIG_LUA_HPP
|
||||
#define NAZARA_CONFIG_LUA_HPP
|
||||
|
||||
/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci
|
||||
|
||||
// Utilise un manager de mémoire pour gérer les allocations dynamiques (détecte les leaks au prix d'allocations/libérations dynamiques plus lentes)
|
||||
#define NAZARA_LUA_MANAGE_MEMORY 0
|
||||
|
||||
// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
|
||||
#define NAZARA_LUA_SAFE 1
|
||||
|
||||
/// Vérification des valeurs et types de certaines constantes
|
||||
#include <Nazara/Lua/ConfigCheck.hpp>
|
||||
|
||||
#if defined(NAZARA_STATIC)
|
||||
#define NAZARA_LUA_API
|
||||
#else
|
||||
#ifdef NAZARA_LUA_BUILD
|
||||
#define NAZARA_LUA_API NAZARA_EXPORT
|
||||
#else
|
||||
#define NAZARA_LUA_API NAZARA_IMPORT
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif // NAZARA_CONFIG_LUA_HPP
|
||||
@@ -1,18 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_CONFIG_CHECK_LUA_HPP
|
||||
#define NAZARA_CONFIG_CHECK_LUA_HPP
|
||||
|
||||
/// Ce fichier sert à vérifier la valeur des constantes du fichier Config.hpp
|
||||
|
||||
// On force la valeur de MANAGE_MEMORY en mode debug
|
||||
#if defined(NAZARA_DEBUG) && !NAZARA_LUA_MANAGE_MEMORY
|
||||
#undef NAZARA_LUA_MANAGE_MEMORY
|
||||
#define NAZARA_LUA_MANAGE_MEMORY 0
|
||||
#endif
|
||||
|
||||
#endif // NAZARA_CONFIG_CHECK_LUA_HPP
|
||||
@@ -1,8 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#include <Nazara/Lua/Config.hpp>
|
||||
#if NAZARA_LUA_MANAGE_MEMORY
|
||||
#include <Nazara/Core/Debug/NewRedefinition.hpp>
|
||||
#endif
|
||||
@@ -1,9 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
// On suppose que Debug.hpp a déjà été inclus, tout comme Config.hpp
|
||||
#if NAZARA_LUA_MANAGE_MEMORY
|
||||
#undef delete
|
||||
#undef new
|
||||
#endif
|
||||
@@ -1,93 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_ENUMS_LUA_HPP
|
||||
#define NAZARA_ENUMS_LUA_HPP
|
||||
|
||||
#include <Nazara/Core/Flags.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
enum LuaBindMode
|
||||
{
|
||||
LuaBindMode_Table,
|
||||
LuaBindMode_Userdata,
|
||||
|
||||
LuaBindMode_Max = LuaBindMode_Userdata
|
||||
};
|
||||
|
||||
enum LuaComparison
|
||||
{
|
||||
LuaComparison_Equality,
|
||||
LuaComparison_Less,
|
||||
LuaComparison_LessOrEqual,
|
||||
|
||||
LuaComparison_Max = LuaComparison_LessOrEqual
|
||||
};
|
||||
|
||||
enum LuaLib
|
||||
{
|
||||
LuaLib_Coroutine,
|
||||
LuaLib_Debug,
|
||||
LuaLib_Math,
|
||||
LuaLib_Io,
|
||||
LuaLib_Package,
|
||||
LuaLib_Os,
|
||||
LuaLib_String,
|
||||
LuaLib_Table,
|
||||
LuaLib_Utf8,
|
||||
|
||||
LuaLib_Max = LuaLib_Utf8
|
||||
};
|
||||
|
||||
enum LuaOperation
|
||||
{
|
||||
LuaOperation_Addition,
|
||||
LuaOperation_BitwiseAnd,
|
||||
LuaOperation_BitwiseLeftShift,
|
||||
LuaOperation_BitwiseNot,
|
||||
LuaOperation_BitwiseOr,
|
||||
LuaOperation_BitwideRightShift,
|
||||
LuaOperation_BitwiseXOr,
|
||||
LuaOperation_Division,
|
||||
LuaOperation_Exponentiation,
|
||||
LuaOperation_FloorDivision,
|
||||
LuaOperation_Modulo,
|
||||
LuaOperation_Multiplication,
|
||||
LuaOperation_Negation,
|
||||
LuaOperation_Substraction,
|
||||
|
||||
LuaOperation_Max = LuaOperation_Substraction
|
||||
};
|
||||
|
||||
enum LuaType
|
||||
{
|
||||
LuaType_Boolean,
|
||||
LuaType_Function,
|
||||
LuaType_LightUserdata,
|
||||
LuaType_Nil,
|
||||
LuaType_Number,
|
||||
LuaType_None,
|
||||
LuaType_String,
|
||||
LuaType_Table,
|
||||
LuaType_Thread,
|
||||
LuaType_Userdata,
|
||||
|
||||
LuaType_Max = LuaType_Userdata
|
||||
};
|
||||
|
||||
template<>
|
||||
struct EnumAsFlags<LuaLib>
|
||||
{
|
||||
static constexpr LuaLib max = LuaLib_Max;
|
||||
};
|
||||
|
||||
using LuaLibFlags = Flags<LuaLib>;
|
||||
|
||||
constexpr LuaLibFlags LuaLib_All = LuaLibFlags(LuaLibFlags::ValueMask);
|
||||
}
|
||||
|
||||
#endif // NAZARA_ENUMS_LUA_HPP
|
||||
@@ -1,32 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_LUA_HPP
|
||||
#define NAZARA_LUA_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Lua/Config.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_LUA_API Lua
|
||||
{
|
||||
public:
|
||||
Lua() = delete;
|
||||
~Lua() = delete;
|
||||
|
||||
static bool Initialize();
|
||||
|
||||
static bool IsInitialized();
|
||||
|
||||
static void Uninitialize();
|
||||
|
||||
private:
|
||||
static unsigned int s_moduleReferenceCounter;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_LUA_HPP
|
||||
@@ -1,121 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_LUACLASS_HPP
|
||||
#define NAZARA_LUACLASS_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Core/Algorithm.hpp>
|
||||
#include <Nazara/Core/String.hpp>
|
||||
#include <Nazara/Lua/LuaInstance.hpp>
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
template<class T>
|
||||
class LuaClass
|
||||
{
|
||||
template<class U>
|
||||
friend class LuaClass;
|
||||
|
||||
public:
|
||||
using ClassFunc = std::function<int(LuaState& state, T& instance, std::size_t argumentCount)>;
|
||||
using ClassIndexFunc = std::function<bool(LuaState& state, T& instance)>;
|
||||
using ConstructorFunc = std::function<bool(LuaState& state, T* instance, std::size_t argumentCount)>;
|
||||
template<typename P> using ConvertToParent = std::function<P*(T*)>;
|
||||
using FinalizerFunc = std::function<bool(LuaState& state, T& instance)>;
|
||||
using StaticIndexFunc = std::function<bool(LuaState& state)>;
|
||||
using StaticFunc = std::function<int(LuaState& state)>;
|
||||
|
||||
LuaClass() = default;
|
||||
LuaClass(const String& name);
|
||||
|
||||
void BindDefaultConstructor();
|
||||
|
||||
void BindMethod(const String& name, ClassFunc method);
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs> std::enable_if_t<std::is_base_of<P, T>::value> BindMethod(const String& name, R(P::*func)(Args...), DefArgs&&... defArgs);
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs> std::enable_if_t<std::is_base_of<P, T>::value> BindMethod(const String& name, R(P::*func)(Args...) const, DefArgs&&... defArgs);
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs> std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value> BindMethod(const String& name, R(P::*func)(Args...), DefArgs&&... defArgs);
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs> std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value> BindMethod(const String& name, R(P::*func)(Args...) const, DefArgs&&... defArgs);
|
||||
|
||||
void BindStaticMethod(const String& name, StaticFunc func);
|
||||
template<typename R, typename... Args, typename... DefArgs> void BindStaticMethod(const String& name, R(*func)(Args...), DefArgs&&... defArgs);
|
||||
|
||||
template<class P> void Inherit(LuaClass<P>& parent);
|
||||
template<class P> void Inherit(LuaClass<P>& parent, ConvertToParent<P> convertFunc);
|
||||
|
||||
void Reset();
|
||||
void Reset(const String& name);
|
||||
|
||||
void Register(LuaState& state);
|
||||
|
||||
void PushGlobalTable(LuaState& state);
|
||||
|
||||
void SetConstructor(ConstructorFunc constructor);
|
||||
void SetFinalizer(FinalizerFunc finalizer);
|
||||
void SetGetter(ClassIndexFunc getter);
|
||||
void SetSetter(ClassIndexFunc setter);
|
||||
void SetStaticGetter(StaticIndexFunc getter);
|
||||
void SetStaticSetter(StaticIndexFunc getter);
|
||||
|
||||
private:
|
||||
template<typename U, bool HasDestructor>
|
||||
friend struct LuaClassImplFinalizerSetupProxy;
|
||||
|
||||
int PushClassInfo(LuaState& state);
|
||||
void SetupConstructor(LuaState& state, int classInfoRef);
|
||||
void SetupDefaultToString(LuaState& state, int classInfoRef);
|
||||
void SetupFinalizer(LuaState& state, int classInfoRef);
|
||||
void SetupGetter(LuaState& state, LuaCFunction proxy, int classInfoRef);
|
||||
void SetupGlobalTable(LuaState& state, int classInfoRef);
|
||||
void SetupMetatable(LuaState& state, int classInfoRef);
|
||||
void SetupMethod(LuaState& state, LuaCFunction proxy, const String& name, std::size_t methodIndex, int classInfoRef);
|
||||
void SetupSetter(LuaState& state, LuaCFunction proxy, int classInfoRef);
|
||||
|
||||
using ParentFunc = std::function<void(LuaState& state, T* instance)>;
|
||||
using InstanceGetter = std::function<T*(LuaState& state)>;
|
||||
|
||||
struct ClassInfo
|
||||
{
|
||||
std::vector<ClassFunc> methods;
|
||||
std::vector<ParentFunc> parentGetters;
|
||||
std::vector<StaticFunc> staticMethods;
|
||||
std::unordered_map<String, InstanceGetter> instanceGetters;
|
||||
ClassIndexFunc getter;
|
||||
ClassIndexFunc setter;
|
||||
ConstructorFunc constructor;
|
||||
FinalizerFunc finalizer;
|
||||
StaticIndexFunc staticGetter;
|
||||
StaticIndexFunc staticSetter;
|
||||
String name;
|
||||
int globalTableRef = -1;
|
||||
};
|
||||
|
||||
static int ConstructorProxy(lua_State* internalState);
|
||||
static int FinalizerProxy(lua_State* internalState);
|
||||
static int InfoDestructor(lua_State* internalState);
|
||||
static void Get(const std::shared_ptr<ClassInfo>& info, LuaState& state, T* instance);
|
||||
static int GetterProxy(lua_State* internalState);
|
||||
static int MethodProxy(lua_State* internalState);
|
||||
static int SetterProxy(lua_State* internalState);
|
||||
static int StaticGetterProxy(lua_State* internalState);
|
||||
static int StaticMethodProxy(lua_State* internalState);
|
||||
static int StaticSetterProxy(lua_State* internalState);
|
||||
static int ToStringProxy(lua_State* internalState);
|
||||
|
||||
std::map<String, ClassFunc> m_methods;
|
||||
std::map<String, StaticFunc> m_staticMethods;
|
||||
std::shared_ptr<ClassInfo> m_info;
|
||||
};
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/LuaClass.inl>
|
||||
|
||||
#endif // NAZARA_LUACLASS_HPP
|
||||
@@ -1,603 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#include <Nazara/Lua/LuaClass.hpp>
|
||||
#include <Nazara/Core/Error.hpp>
|
||||
#include <Nazara/Core/MemoryHelper.hpp>
|
||||
#include <type_traits>
|
||||
#include <Nazara/Lua/Debug.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
template<class T>
|
||||
LuaClass<T>::LuaClass(const String& name)
|
||||
{
|
||||
Reset(name);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void LuaClass<T>::BindDefaultConstructor()
|
||||
{
|
||||
SetConstructor([] (Nz::LuaState& state, T* instance, std::size_t argumentCount)
|
||||
{
|
||||
NazaraUnused(state);
|
||||
NazaraUnused(argumentCount);
|
||||
|
||||
PlacementNew(instance);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<class P>
|
||||
inline void LuaClass<T>::Inherit(LuaClass<P>& parent)
|
||||
{
|
||||
Inherit<P>(parent, [] (T* instance) -> P*
|
||||
{
|
||||
return static_cast<P*>(instance);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<class P>
|
||||
inline void LuaClass<T>::Inherit(LuaClass<P>& parent, ConvertToParent<P> convertFunc)
|
||||
{
|
||||
static_assert(!std::is_same<P, T>::value || std::is_base_of<P, T>::value, "P must be a base of T");
|
||||
|
||||
std::shared_ptr<typename LuaClass<P>::ClassInfo>& parentInfo = parent.m_info;
|
||||
|
||||
parentInfo->instanceGetters[m_info->name] = [info = m_info, convertFunc] (LuaState& state) -> P*
|
||||
{
|
||||
return convertFunc(static_cast<T*>(state.CheckUserdata(1, info->name)));
|
||||
};
|
||||
|
||||
m_info->parentGetters.emplace_back([parentInfo, convertFunc] (LuaState& state, T* instance)
|
||||
{
|
||||
LuaClass<P>::Get(parentInfo, state, convertFunc(instance));
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::Reset()
|
||||
{
|
||||
m_info.reset();
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::Reset(const String& name)
|
||||
{
|
||||
m_info = std::make_shared<ClassInfo>();
|
||||
m_info->name = name;
|
||||
|
||||
m_info->instanceGetters[m_info->name] = [info = m_info] (LuaState& state)
|
||||
{
|
||||
return static_cast<T*>(state.CheckUserdata(1, info->name));
|
||||
};
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::Register(LuaState& state)
|
||||
{
|
||||
int classInfoRef = PushClassInfo(state);
|
||||
|
||||
// Let's create the metatable which will be associated with every state.
|
||||
SetupMetatable(state, classInfoRef);
|
||||
|
||||
if (m_info->constructor || m_info->staticGetter || m_info->staticSetter || !m_staticMethods.empty())
|
||||
SetupGlobalTable(state, classInfoRef);
|
||||
|
||||
state.DestroyReference(classInfoRef);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::PushGlobalTable(LuaState& state)
|
||||
{
|
||||
state.PushReference(m_info->globalTableRef);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetConstructor(ConstructorFunc constructor)
|
||||
{
|
||||
m_info->constructor = constructor;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetFinalizer(FinalizerFunc finalizer)
|
||||
{
|
||||
m_info->finalizer = finalizer;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetGetter(ClassIndexFunc getter)
|
||||
{
|
||||
m_info->getter = getter;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::BindMethod(const String& name, ClassFunc method)
|
||||
{
|
||||
m_methods[name] = method;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value> LuaClass<T>::BindMethod(const String& name, R(P::*func)(Args...), DefArgs&&... defArgs)
|
||||
{
|
||||
typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
BindMethod(name, [func, handler] (LuaState& state, T& object, std::size_t /*argumentCount*/) -> int
|
||||
{
|
||||
handler.ProcessArguments(state);
|
||||
|
||||
return handler.Invoke(state, object, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value> LuaClass<T>::BindMethod(const String& name, R(P::*func)(Args...) const, DefArgs&&... defArgs)
|
||||
{
|
||||
typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
BindMethod(name, [func, handler] (LuaState& state, T& object, std::size_t /*argumentCount*/) -> int
|
||||
{
|
||||
handler.ProcessArguments(state);
|
||||
|
||||
return handler.Invoke(state, object, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value> LuaClass<T>::BindMethod(const String& name, R(P::*func)(Args...), DefArgs&&... defArgs)
|
||||
{
|
||||
typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
BindMethod(name, [func, handler] (LuaState& state, T& object, std::size_t /*argumentCount*/) -> int
|
||||
{
|
||||
handler.ProcessArguments(state);
|
||||
|
||||
return handler.Invoke(state, object, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<typename R, typename P, typename... Args, typename... DefArgs>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value> LuaClass<T>::BindMethod(const String& name, R(P::*func)(Args...) const, DefArgs&&... defArgs)
|
||||
{
|
||||
typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
BindMethod(name, [func, handler] (LuaState& state, T& object, std::size_t /*argumentCount*/) -> int
|
||||
{
|
||||
handler.ProcessArguments(state);
|
||||
|
||||
return handler.Invoke(state, object, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetSetter(ClassIndexFunc setter)
|
||||
{
|
||||
m_info->setter = setter;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetStaticGetter(StaticIndexFunc getter)
|
||||
{
|
||||
m_info->staticGetter = getter;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::BindStaticMethod(const String& name, StaticFunc method)
|
||||
{
|
||||
m_staticMethods[name] = method;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
template<typename R, typename... Args, typename... DefArgs>
|
||||
void LuaClass<T>::BindStaticMethod(const String& name, R(*func)(Args...), DefArgs&&... defArgs)
|
||||
{
|
||||
typename LuaImplFunctionProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
BindStaticMethod(name, [func, handler] (LuaState& state) -> int
|
||||
{
|
||||
handler.ProcessArguments(state);
|
||||
|
||||
return handler.Invoke(state, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetStaticSetter(StaticIndexFunc setter)
|
||||
{
|
||||
m_info->staticSetter = setter;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::PushClassInfo(LuaState& state)
|
||||
{
|
||||
// Our ClassInfo has to outlive the LuaClass, because we don't want to force the user to keep the LuaClass alive
|
||||
// To do that, each Registration creates a tiny shared_ptr wrapper whose life is directly managed by Lua.
|
||||
// This shared_ptr object gets pushed as a up-value for every proxy function set in the metatable.
|
||||
// This way, there is no way our ClassInfo gets freed before any instance and the global class gets destroyed.
|
||||
std::shared_ptr<ClassInfo>* info = static_cast<std::shared_ptr<ClassInfo>*>(state.PushUserdata(sizeof(std::shared_ptr<ClassInfo>)));
|
||||
PlacementNew(info, m_info);
|
||||
|
||||
// Setup a tiny metatable to let Lua know how to destroy our ClassInfo
|
||||
state.PushTable(0, 1);
|
||||
state.PushLightUserdata(info);
|
||||
state.PushCFunction(InfoDestructor, 1);
|
||||
state.SetField("__gc");
|
||||
state.SetMetatable(-2);
|
||||
|
||||
return state.CreateReference();
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupConstructor(LuaState& state, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushCFunction(ConstructorProxy, 1);
|
||||
state.SetField("__call"); // ClassMeta.__call = ConstructorProxy
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupDefaultToString(LuaState& state, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushCFunction(ToStringProxy, 1);
|
||||
state.SetField("__tostring");
|
||||
}
|
||||
|
||||
template<typename T, bool HasDestructor>
|
||||
struct LuaClassImplFinalizerSetupProxy;
|
||||
|
||||
template<typename T>
|
||||
struct LuaClassImplFinalizerSetupProxy<T, true>
|
||||
{
|
||||
static void Setup(LuaState& state, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushCFunction(LuaClass<T>::FinalizerProxy, 1);
|
||||
state.SetField("__gc");
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct LuaClassImplFinalizerSetupProxy<T, false>
|
||||
{
|
||||
static void Setup(LuaState&, int)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupFinalizer(LuaState& state, int classInfoRef)
|
||||
{
|
||||
LuaClassImplFinalizerSetupProxy<T, std::is_destructible<T>::value>::Setup(state, classInfoRef);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupGetter(LuaState& state, LuaCFunction proxy, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushValue(-2); // Metatable
|
||||
state.PushCFunction(proxy, 2);
|
||||
|
||||
state.SetField("__index"); // Getter
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupGlobalTable(LuaState& state, int classInfoRef)
|
||||
{
|
||||
// Create the global table
|
||||
state.PushTable(); // Class = {}
|
||||
|
||||
// Create a metatable which will be used for our global table
|
||||
state.PushTable(); // ClassMeta = {}
|
||||
|
||||
if (m_info->constructor)
|
||||
SetupConstructor(state, classInfoRef);
|
||||
|
||||
if (m_info->staticGetter)
|
||||
SetupGetter(state, StaticGetterProxy, classInfoRef);
|
||||
else
|
||||
{
|
||||
// Optimize by assigning the metatable instead of a search function
|
||||
state.PushValue(-1); // Metatable
|
||||
state.SetField("__index");
|
||||
}
|
||||
|
||||
if (m_info->staticSetter)
|
||||
SetupSetter(state, StaticSetterProxy, classInfoRef);
|
||||
|
||||
m_info->staticMethods.reserve(m_staticMethods.size());
|
||||
for (auto& pair : m_staticMethods)
|
||||
{
|
||||
std::size_t methodIndex = m_info->staticMethods.size();
|
||||
m_info->staticMethods.push_back(pair.second);
|
||||
|
||||
SetupMethod(state, StaticMethodProxy, pair.first, methodIndex, classInfoRef);
|
||||
}
|
||||
|
||||
state.SetMetatable(-2); // setmetatable(Class, ClassMeta), pops ClassMeta
|
||||
|
||||
state.PushValue(-1); // As CreateReference() pops the table, push a copy
|
||||
m_info->globalTableRef = state.CreateReference();
|
||||
|
||||
state.SetGlobal(m_info->name); // _G["Class"] = Class
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupMetatable(LuaState& state, int classInfoRef)
|
||||
{
|
||||
if (!state.NewMetatable(m_info->name))
|
||||
NazaraWarning("Class \"" + m_info->name + "\" already registred in this instance");
|
||||
{
|
||||
SetupFinalizer(state, classInfoRef);
|
||||
|
||||
if (m_info->getter || !m_info->parentGetters.empty())
|
||||
SetupGetter(state, GetterProxy, classInfoRef);
|
||||
else
|
||||
{
|
||||
// Optimize by assigning the metatable instead of a search function
|
||||
// This is only possible if we have no custom getter nor parent
|
||||
state.PushValue(-1); // Metatable
|
||||
state.SetField("__index");
|
||||
}
|
||||
|
||||
if (m_info->setter)
|
||||
SetupSetter(state, SetterProxy, classInfoRef);
|
||||
|
||||
// In case a __tostring method is missing, add a default implementation returning the class name
|
||||
if (m_methods.find("__tostring") == m_methods.end())
|
||||
SetupDefaultToString(state, classInfoRef);
|
||||
|
||||
m_info->methods.reserve(m_methods.size());
|
||||
for (auto& pair : m_methods)
|
||||
{
|
||||
std::size_t methodIndex = m_info->methods.size();
|
||||
m_info->methods.push_back(pair.second);
|
||||
|
||||
SetupMethod(state, MethodProxy, pair.first, methodIndex, classInfoRef);
|
||||
}
|
||||
}
|
||||
state.Pop(); //< Pops the metatable, it won't be collected before it's referenced by the Lua registry.
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupMethod(LuaState& state, LuaCFunction proxy, const String& name, std::size_t methodIndex, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushInteger(methodIndex);
|
||||
state.PushCFunction(proxy, 2);
|
||||
|
||||
state.SetField(name); // Method name
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::SetupSetter(LuaState& state, LuaCFunction proxy, int classInfoRef)
|
||||
{
|
||||
state.PushReference(classInfoRef);
|
||||
state.PushCFunction(proxy, 1);
|
||||
|
||||
state.SetField("__newindex"); // Setter
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::ConstructorProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
const ConstructorFunc& constructor = info->constructor;
|
||||
|
||||
state.Remove(1); // On enlève l'argument "table" du stack
|
||||
|
||||
std::size_t argCount = state.GetStackTop();
|
||||
|
||||
T* instance = static_cast<T*>(state.PushUserdata(sizeof(T)));
|
||||
|
||||
if (!constructor(state, instance, argCount))
|
||||
{
|
||||
state.Error("Constructor failed");
|
||||
return 0; // Normalement jamais exécuté (l'erreur provoquant une exception)
|
||||
}
|
||||
|
||||
state.SetMetatable(info->name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::FinalizerProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
const FinalizerFunc& finalizer = info->finalizer;
|
||||
|
||||
T* instance = static_cast<T*>(state.CheckUserdata(1, info->name));
|
||||
state.Remove(1); //< Remove the instance from the Lua stack
|
||||
|
||||
if (!finalizer || finalizer(state, *instance))
|
||||
instance->~T();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::InfoDestructor(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
state.DestroyReference(info->globalTableRef);
|
||||
|
||||
using namespace std; // Obligatoire pour le destructeur
|
||||
info.~shared_ptr(); // Si vous voyez une autre façon de faire, je suis preneur
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void LuaClass<T>::Get(const std::shared_ptr<ClassInfo>& info, LuaState& state, T* instance)
|
||||
{
|
||||
const ClassIndexFunc& getter = info->getter;
|
||||
|
||||
if (!getter || !getter(state, *instance))
|
||||
{
|
||||
// Query from the metatable
|
||||
state.GetMetatable(info->name); //< Metatable
|
||||
state.PushValue(2); //< Field
|
||||
state.GetTable(); // Metatable[Field]
|
||||
|
||||
state.Remove(-2); // Remove Metatable
|
||||
|
||||
if (!state.IsValid(-1))
|
||||
{
|
||||
for (const ParentFunc& parentGetter : info->parentGetters)
|
||||
{
|
||||
state.Pop(); //< Pop the last nil value
|
||||
|
||||
parentGetter(state, instance);
|
||||
if (state.IsValid(-1))
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::GetterProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
|
||||
T* instance = static_cast<T*>(state.CheckUserdata(1, info->name));
|
||||
|
||||
Get(info, state, instance);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::MethodProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
|
||||
T* instance = nullptr;
|
||||
if (state.GetMetatable(1))
|
||||
{
|
||||
LuaType type = state.GetField("__name");
|
||||
if (type == LuaType_String)
|
||||
{
|
||||
String name = state.ToString(-1);
|
||||
auto it = info->instanceGetters.find(name);
|
||||
if (it != info->instanceGetters.end())
|
||||
instance = it->second(state);
|
||||
}
|
||||
state.Pop(2);
|
||||
}
|
||||
|
||||
if (!instance)
|
||||
{
|
||||
state.Error("Method cannot be called without an object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::size_t argCount = state.GetStackTop() - 1U;
|
||||
|
||||
unsigned int index = static_cast<unsigned int>(state.ToInteger(state.GetIndexOfUpValue(2)));
|
||||
const ClassFunc& method = info->methods[index];
|
||||
return method(state, *instance, argCount);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::SetterProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
const ClassIndexFunc& setter = info->setter;
|
||||
|
||||
T& instance = *static_cast<T*>(state.CheckUserdata(1, info->name));
|
||||
|
||||
if (!setter(state, instance))
|
||||
{
|
||||
std::size_t length;
|
||||
const char* str = state.ToString(2, &length);
|
||||
|
||||
state.Error("Class \"" + info->name + "\" has no field \"" + String(str, length) + "\")");
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::StaticGetterProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
const StaticIndexFunc& getter = info->staticGetter;
|
||||
|
||||
if (!getter(state))
|
||||
{
|
||||
// On accède alors à la table
|
||||
state.PushValue(state.GetIndexOfUpValue(2));
|
||||
state.PushValue(-2);
|
||||
state.GetTable();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::StaticMethodProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
unsigned int index = static_cast<unsigned int>(state.ToInteger(state.GetIndexOfUpValue(2)));
|
||||
const StaticFunc& method = info->staticMethods[index];
|
||||
|
||||
return method(state);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::StaticSetterProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
const StaticIndexFunc& setter = info->staticSetter;
|
||||
|
||||
if (!setter(state))
|
||||
{
|
||||
std::size_t length;
|
||||
const char* str = state.ToString(2, &length);
|
||||
|
||||
state.Error("Class \"" + info->name + "\" has no static field \"" + String(str, length) + ')');
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
int LuaClass<T>::ToStringProxy(lua_State* internalState)
|
||||
{
|
||||
LuaState state = LuaInstance::GetState(internalState);
|
||||
|
||||
std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(state.ToUserdata(state.GetIndexOfUpValue(1)));
|
||||
|
||||
state.PushString(info->name);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/DebugOff.hpp>
|
||||
@@ -1,42 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_LUACOROUTINE_HPP
|
||||
#define NAZARA_LUACOROUTINE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Lua/LuaState.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_LUA_API LuaCoroutine : public LuaState
|
||||
{
|
||||
friend class LuaState;
|
||||
|
||||
public:
|
||||
LuaCoroutine(const LuaCoroutine&) = delete;
|
||||
inline LuaCoroutine(LuaCoroutine&& instance);
|
||||
~LuaCoroutine();
|
||||
|
||||
bool CanResume() const;
|
||||
|
||||
Ternary Resume(unsigned int argCount = 0);
|
||||
|
||||
LuaCoroutine& operator=(const LuaCoroutine&) = delete;
|
||||
inline LuaCoroutine& operator=(LuaCoroutine&& instance);
|
||||
|
||||
private:
|
||||
LuaCoroutine(lua_State* internalState, int refIndex);
|
||||
|
||||
bool Run(int argCount, int resultCount, int errHandler) override;
|
||||
|
||||
int m_ref;
|
||||
};
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/LuaCoroutine.inl>
|
||||
|
||||
#endif // NAZARA_LUACOROUTINE_HPP
|
||||
@@ -1,22 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
inline LuaCoroutine::LuaCoroutine(LuaCoroutine&& instance) :
|
||||
LuaState(std::move(instance)),
|
||||
m_ref(instance.m_ref)
|
||||
{
|
||||
instance.m_ref = -1;
|
||||
}
|
||||
|
||||
inline LuaCoroutine& LuaCoroutine::operator=(LuaCoroutine&& instance)
|
||||
{
|
||||
LuaState::operator=(std::move(instance));
|
||||
|
||||
std::swap(m_ref, instance.m_ref);
|
||||
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_LUAINSTANCE_HPP
|
||||
#define NAZARA_LUAINSTANCE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Core/Clock.hpp>
|
||||
#include <Nazara/Lua/Enums.hpp>
|
||||
#include <Nazara/Lua/LuaState.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_LUA_API LuaInstance : public LuaState
|
||||
{
|
||||
friend class LuaCoroutine;
|
||||
friend class LuaState;
|
||||
|
||||
public:
|
||||
LuaInstance();
|
||||
LuaInstance(const LuaInstance&) = delete;
|
||||
LuaInstance(LuaInstance&& instance);
|
||||
~LuaInstance();
|
||||
|
||||
inline std::size_t GetMemoryLimit() const;
|
||||
inline std::size_t GetMemoryUsage() const;
|
||||
inline UInt32 GetTimeLimit() const;
|
||||
|
||||
void LoadLibraries(LuaLibFlags libFlags = LuaLib_All);
|
||||
|
||||
inline void SetMemoryLimit(std::size_t memoryLimit);
|
||||
inline void SetTimeLimit(UInt32 limit);
|
||||
|
||||
LuaInstance& operator=(const LuaInstance&) = delete;
|
||||
LuaInstance& operator=(LuaInstance&& instance);
|
||||
|
||||
private:
|
||||
inline void SetMemoryUsage(std::size_t memoryUsage);
|
||||
|
||||
static void* MemoryAllocator(void *ud, void *ptr, std::size_t osize, std::size_t nsize);
|
||||
static void TimeLimiter(lua_State* internalState, lua_Debug* debug);
|
||||
|
||||
std::size_t m_memoryLimit;
|
||||
std::size_t m_memoryUsage;
|
||||
UInt32 m_timeLimit;
|
||||
Clock m_clock;
|
||||
unsigned int m_level;
|
||||
};
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/LuaInstance.inl>
|
||||
|
||||
#endif // NAZARA_LUAINSTANCE_HPP
|
||||
@@ -1,40 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#include <Nazara/Lua/Debug.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
inline std::size_t LuaInstance::GetMemoryLimit() const
|
||||
{
|
||||
return m_memoryLimit;
|
||||
}
|
||||
|
||||
inline std::size_t LuaInstance::GetMemoryUsage() const
|
||||
{
|
||||
return m_memoryUsage;
|
||||
}
|
||||
|
||||
inline UInt32 LuaInstance::GetTimeLimit() const
|
||||
{
|
||||
return m_timeLimit;
|
||||
}
|
||||
|
||||
inline void LuaInstance::SetMemoryLimit(std::size_t memoryLimit)
|
||||
{
|
||||
m_memoryLimit = memoryLimit;
|
||||
}
|
||||
|
||||
inline void LuaInstance::SetTimeLimit(UInt32 limit)
|
||||
{
|
||||
m_timeLimit = limit;
|
||||
}
|
||||
|
||||
inline void LuaInstance::SetMemoryUsage(std::size_t memoryUsage)
|
||||
{
|
||||
m_memoryUsage = memoryUsage;
|
||||
}
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/DebugOff.hpp>
|
||||
@@ -1,210 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_LUASTATE_HPP
|
||||
#define NAZARA_LUASTATE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Core/MovablePtr.hpp>
|
||||
#include <Nazara/Core/String.hpp>
|
||||
#include <Nazara/Lua/Config.hpp>
|
||||
#include <Nazara/Lua/Enums.hpp>
|
||||
#include <cstddef>
|
||||
#include <filesystem>
|
||||
#include <functional>
|
||||
#include <type_traits>
|
||||
|
||||
struct lua_Debug;
|
||||
struct lua_State;
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class LuaCoroutine;
|
||||
class LuaInstance;
|
||||
class LuaState;
|
||||
class Stream;
|
||||
|
||||
using LuaCFunction = int (*)(lua_State* internalState);
|
||||
using LuaFunction = std::function<int(LuaState& state)>;
|
||||
|
||||
class NAZARA_LUA_API LuaState
|
||||
{
|
||||
public:
|
||||
LuaState(const LuaState&) = default;
|
||||
LuaState(LuaState&& instance) = default;
|
||||
~LuaState() = default;
|
||||
|
||||
void ArgCheck(bool condition, unsigned int argNum, const char* error) const;
|
||||
void ArgCheck(bool condition, unsigned int argNum, const String& error) const;
|
||||
int ArgError(unsigned int argNum, const char* error) const;
|
||||
int ArgError(unsigned int argNum, const String& error) const;
|
||||
|
||||
bool Call(unsigned int argCount);
|
||||
bool Call(unsigned int argCount, unsigned int resultCount);
|
||||
bool CallWithHandler(unsigned int argCount, int errorHandler);
|
||||
bool CallWithHandler(unsigned int argCount, unsigned int resultCount, int errorHandler);
|
||||
|
||||
template<typename T> T Check(int* index) const;
|
||||
template<typename T> T Check(int* index, T defValue) const;
|
||||
void CheckAny(int index) const;
|
||||
bool CheckBoolean(int index) const;
|
||||
bool CheckBoolean(int index, bool defValue) const;
|
||||
template<typename T> T CheckBoundInteger(int index) const;
|
||||
template<typename T> T CheckBoundInteger(int index, T defValue) const;
|
||||
template<typename T> T CheckField(const char* fieldName, int tableIndex = -1) const;
|
||||
template<typename T> T CheckField(const String& fieldName, int tableIndex = -1) const;
|
||||
template<typename T> T CheckField(const char* fieldName, T defValue, int tableIndex = -1) const;
|
||||
template<typename T> T CheckField(const String& fieldName, T defValue, int tableIndex = -1) const;
|
||||
long long CheckInteger(int index) const;
|
||||
long long CheckInteger(int index, long long defValue) const;
|
||||
template<typename T> T CheckGlobal(const char* fieldName) const;
|
||||
template<typename T> T CheckGlobal(const String& fieldName) const;
|
||||
template<typename T> T CheckGlobal(const char* fieldName, T defValue) const;
|
||||
template<typename T> T CheckGlobal(const String& fieldName, T defValue) const;
|
||||
double CheckNumber(int index) const;
|
||||
double CheckNumber(int index, double defValue) const;
|
||||
void CheckStack(int space, const char* error = nullptr) const;
|
||||
void CheckStack(int space, const String& error) const;
|
||||
const char* CheckString(int index, std::size_t* length = nullptr) const;
|
||||
const char* CheckString(int index, const char* defValue, std::size_t* length = nullptr) const;
|
||||
void CheckType(int index, LuaType type) const;
|
||||
void* CheckUserdata(int index, const char* tname) const;
|
||||
void* CheckUserdata(int index, const String& tname) const;
|
||||
|
||||
bool Compare(int index1, int index2, LuaComparison comparison) const;
|
||||
void Compute(LuaOperation operation) const;
|
||||
|
||||
void Concatenate(int count) const;
|
||||
|
||||
int CreateReference();
|
||||
void DestroyReference(int ref);
|
||||
|
||||
String DumpStack() const;
|
||||
|
||||
void Error(const char* message) const;
|
||||
void Error(const String& message) const;
|
||||
|
||||
bool Execute(const String& code, int errorHandler = 0);
|
||||
bool ExecuteFromFile(const std::filesystem::path& filePath, int errorHandler = 0);
|
||||
bool ExecuteFromMemory(const void* data, std::size_t size, int errorHandler = 0);
|
||||
bool ExecuteFromStream(Stream& stream, int errorHandler = 0);
|
||||
|
||||
int GetAbsIndex(int index) const;
|
||||
LuaType GetField(const char* fieldName, int tableIndex = -1) const;
|
||||
LuaType GetField(const String& fieldName, int tableIndex = -1) const;
|
||||
LuaType GetGlobal(const char* name) const;
|
||||
LuaType GetGlobal(const String& name) const;
|
||||
inline lua_State* GetInternalState() const;
|
||||
inline String GetLastError() const;
|
||||
LuaType GetMetatable(const char* tname) const;
|
||||
LuaType GetMetatable(const String& tname) const;
|
||||
bool GetMetatable(int index) const;
|
||||
unsigned int GetStackTop() const;
|
||||
LuaType GetTable(int index = -2) const;
|
||||
LuaType GetTableRaw(int index = -2) const;
|
||||
LuaType GetType(int index) const;
|
||||
const char* GetTypeName(LuaType type) const;
|
||||
|
||||
void Insert(int index) const;
|
||||
|
||||
bool IsOfType(int index, LuaType type) const;
|
||||
bool IsOfType(int index, const char* tname) const;
|
||||
bool IsOfType(int index, const String& tname) const;
|
||||
bool IsValid(int index) const;
|
||||
|
||||
bool Load(const String& code);
|
||||
bool LoadFromFile(const std::filesystem::path& filePath);
|
||||
bool LoadFromMemory(const void* data, std::size_t size);
|
||||
bool LoadFromStream(Stream& stream);
|
||||
|
||||
long long Length(int index) const;
|
||||
std::size_t LengthRaw(int index) const;
|
||||
|
||||
void MoveTo(LuaState* instance, int n) const;
|
||||
|
||||
LuaCoroutine NewCoroutine();
|
||||
bool NewMetatable(const char* str);
|
||||
bool NewMetatable(const String& str);
|
||||
bool Next(int index = -2) const;
|
||||
|
||||
void Pop(unsigned int n = 1U) const;
|
||||
|
||||
template<typename T> int Push(T arg) const;
|
||||
template<typename T, typename T2, typename... Args> int Push(T firstArg, T2 secondArg, Args... args) const;
|
||||
void PushBoolean(bool value) const;
|
||||
void PushCFunction(LuaCFunction func, unsigned int upvalueCount = 0) const;
|
||||
template<typename T> void PushField(const char* name, T&& arg, int tableIndex = -2) const;
|
||||
template<typename T> void PushField(const String& name, T&& arg, int tableIndex = -2) const;
|
||||
void PushFunction(LuaFunction func) const;
|
||||
template<typename R, typename... Args, typename... DefArgs> void PushFunction(R(*func)(Args...), DefArgs&&... defArgs) const;
|
||||
template<typename T> void PushGlobal(const char* name, T&& arg);
|
||||
template<typename T> void PushGlobal(const String& name, T&& arg);
|
||||
template<typename T> void PushInstance(const char* tname, T&& instance) const;
|
||||
template<typename T, typename... Args> void PushInstance(const char* tname, Args&&... args) const;
|
||||
void PushInteger(long long value) const;
|
||||
void PushLightUserdata(void* value) const;
|
||||
void PushMetatable(const char* str) const;
|
||||
void PushMetatable(const String& str) const;
|
||||
void PushNil() const;
|
||||
void PushNumber(double value) const;
|
||||
void PushReference(int ref) const;
|
||||
void PushString(const char* str) const;
|
||||
void PushString(const char* str, std::size_t size) const;
|
||||
void PushString(const String& str) const;
|
||||
void PushTable(std::size_t sequenceElementCount = 0, std::size_t arrayElementCount = 0) const;
|
||||
void* PushUserdata(std::size_t size) const;
|
||||
void PushValue(int index) const;
|
||||
|
||||
bool RawEqual(int index1, int index2) const;
|
||||
|
||||
void Remove(int index) const;
|
||||
void Replace(int index) const;
|
||||
|
||||
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;
|
||||
void SetMetatable(const String& tname) const;
|
||||
void SetMetatable(int index) const;
|
||||
void SetTable(int index = -3) const;
|
||||
void SetTableRaw(int index = -3) const;
|
||||
|
||||
bool ToBoolean(int index) const;
|
||||
long long ToInteger(int index, bool* succeeded = nullptr) const;
|
||||
double ToNumber(int index, bool* succeeded = nullptr) const;
|
||||
const void* ToPointer(int index) const;
|
||||
const char* ToString(int index, std::size_t* length = nullptr) const;
|
||||
void* ToUserdata(int index) const;
|
||||
void* ToUserdata(int index, const char* tname) const;
|
||||
void* ToUserdata(int index, const String& tname) const;
|
||||
|
||||
void Traceback(const char* message = nullptr, int level = 0);
|
||||
|
||||
LuaState& operator=(const LuaState&) = default;
|
||||
LuaState& operator=(LuaState&& instance) = default;
|
||||
|
||||
static int GetIndexOfUpValue(int upValue);
|
||||
static LuaInstance& GetInstance(lua_State* internalState);
|
||||
static inline LuaState GetState(lua_State* internalState);
|
||||
|
||||
protected:
|
||||
LuaState(lua_State* internalState);
|
||||
|
||||
template<typename T> std::enable_if_t<std::is_signed<T>::value, T> CheckBounds(int index, long long value) const;
|
||||
template<typename T> std::enable_if_t<std::is_unsigned<T>::value, T> CheckBounds(int index, long long value) const;
|
||||
virtual bool Run(int argCount, int resultCount, int errHandler);
|
||||
|
||||
static int ProxyFunc(lua_State* internalState);
|
||||
|
||||
MovablePtr<lua_State> m_state;
|
||||
String m_lastError;
|
||||
};
|
||||
}
|
||||
|
||||
#include <Nazara/Lua/LuaState.inl>
|
||||
|
||||
#endif // NAZARA_LUASTATE_HPP
|
||||
@@ -1,843 +0,0 @@
|
||||
// Copyright (C) 2017 Jérôme Leclercq
|
||||
// This file is part of the "Nazara Engine - Lua scripting module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#include <Nazara/Core/Algorithm.hpp>
|
||||
#include <Nazara/Core/CallOnExit.hpp>
|
||||
#include <Nazara/Core/Flags.hpp>
|
||||
#include <Nazara/Core/MemoryHelper.hpp>
|
||||
#include <Nazara/Core/StringStream.hpp>
|
||||
#include <Nazara/Math/Algorithm.hpp>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <type_traits>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
inline LuaState::LuaState(lua_State* internalState) :
|
||||
m_state(internalState)
|
||||
{
|
||||
}
|
||||
|
||||
inline lua_State* LuaState::GetInternalState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
inline String LuaState::GetLastError() const
|
||||
{
|
||||
return m_lastError;
|
||||
}
|
||||
|
||||
// Functions args
|
||||
inline unsigned int LuaImplQueryArg(const LuaState& instance, int index, bool* arg, TypeTag<bool>)
|
||||
{
|
||||
*arg = instance.CheckBoolean(index);
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline unsigned int LuaImplQueryArg(const LuaState& instance, int index, bool* arg, bool defValue, TypeTag<bool>)
|
||||
{
|
||||
*arg = instance.CheckBoolean(index, defValue);
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline unsigned int LuaImplQueryArg(const LuaState& instance, int index, std::filesystem::path* arg, TypeTag<std::filesystem::path>)
|
||||
{
|
||||
std::size_t strLength = 0;
|
||||
const char* str = instance.CheckString(index, &strLength);
|
||||
|
||||
arg->assign(std::string_view(str, strLength));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline unsigned int LuaImplQueryArg(const LuaState& instance, int index, std::string* arg, TypeTag<std::string>)
|
||||
{
|
||||
std::size_t strLength = 0;
|
||||
const char* str = instance.CheckString(index, &strLength);
|
||||
|
||||
arg->assign(str, strLength);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline unsigned int LuaImplQueryArg(const LuaState& instance, int index, String* arg, TypeTag<String>)
|
||||
{
|
||||
std::size_t strLength = 0;
|
||||
const char* str = instance.CheckString(index, &strLength);
|
||||
|
||||
arg->Set(str, strLength);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && !IsEnumFlag<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, TypeTag<T>)
|
||||
{
|
||||
using UnderlyingT = std::underlying_type_t<T>;
|
||||
return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), TypeTag<UnderlyingT>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && !IsEnumFlag<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, T defValue, TypeTag<T>)
|
||||
{
|
||||
using UnderlyingT = std::underlying_type_t<T>;
|
||||
return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && IsEnumFlag<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, TypeTag<T>)
|
||||
{
|
||||
using UnderlyingT = std::underlying_type_t<T>;
|
||||
|
||||
UnderlyingT pot2Val;
|
||||
unsigned int ret = LuaImplQueryArg(instance, index, &pot2Val, TypeTag<UnderlyingT>());
|
||||
|
||||
*arg = static_cast<T>(IntegralLog2Pot(pot2Val));
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && IsEnumFlag<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, T defValue, TypeTag<T>)
|
||||
{
|
||||
using UnderlyingT = std::underlying_type_t<T>;
|
||||
|
||||
UnderlyingT pot2Val;
|
||||
unsigned int ret = LuaImplQueryArg(instance, index, &pot2Val, 1U << static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>());
|
||||
|
||||
*arg = static_cast<T>(IntegralLog2Pot(pot2Val));
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename E>
|
||||
unsigned int LuaImplQueryArg(const LuaState& instance, int index, Flags<E>* arg, TypeTag<Flags<E>>)
|
||||
{
|
||||
*arg = Flags<E>(instance.CheckBoundInteger<UInt32>(index));
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_floating_point<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, TypeTag<T>)
|
||||
{
|
||||
*arg = static_cast<T>(instance.CheckNumber(index));
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_floating_point<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, T defValue, TypeTag<T>)
|
||||
{
|
||||
*arg = static_cast<T>(instance.CheckNumber(index, static_cast<double>(defValue)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_integral<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, TypeTag<T>)
|
||||
{
|
||||
*arg = instance.CheckBoundInteger<T>(index);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_integral<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, T defValue, TypeTag<T>)
|
||||
{
|
||||
*arg = instance.CheckBoundInteger<T>(index, defValue);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<!std::is_integral<T>::value && !std::is_enum<T>::value && !std::is_floating_point<T>::value, unsigned int> LuaImplQueryArg(const LuaState& instance, int index, T* arg, const T& defValue, TypeTag<T> tag)
|
||||
{
|
||||
if (instance.IsValid(index))
|
||||
return LuaImplQueryArg(instance, index, arg, tag);
|
||||
else
|
||||
{
|
||||
*arg = defValue;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
unsigned int LuaImplQueryArg(const LuaState& instance, int index, T* arg, TypeTag<const T&>)
|
||||
{
|
||||
return LuaImplQueryArg(instance, index, arg, TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
unsigned int LuaImplQueryArg(const LuaState& instance, int index, T* arg, const T& defValue, TypeTag<const T&>)
|
||||
{
|
||||
return LuaImplQueryArg(instance, index, arg, defValue, TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
unsigned int LuaImplQueryArg(const LuaState& instance, int index, std::vector<T>* container, TypeTag<std::vector<T>>)
|
||||
{
|
||||
instance.CheckType(index, Nz::LuaType_Table);
|
||||
std::size_t pos = 1;
|
||||
|
||||
container->clear();
|
||||
for (;;)
|
||||
{
|
||||
Nz::CallOnExit popStack { [&instance]() { instance.Pop(); } };
|
||||
instance.PushInteger(pos++);
|
||||
|
||||
int tableIndex = (index < 0) ? index - 1 : index;
|
||||
if (instance.GetTable(tableIndex) == Nz::LuaType_Nil)
|
||||
break;
|
||||
|
||||
T arg;
|
||||
if (LuaImplQueryArg(instance, -1, &arg, TypeTag<T>()) != 1)
|
||||
{
|
||||
instance.Error("Type needs more than one place to be initialized");
|
||||
return 0;
|
||||
}
|
||||
|
||||
container->push_back(arg);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Function returns
|
||||
inline int LuaImplReplyVal(const LuaState& instance, bool val, TypeTag<bool>)
|
||||
{
|
||||
instance.PushBoolean(val);
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, double val, TypeTag<double>)
|
||||
{
|
||||
instance.PushNumber(val);
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, float val, TypeTag<float>)
|
||||
{
|
||||
instance.PushNumber(val);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && !IsEnumFlag<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<T>)
|
||||
{
|
||||
using EnumT = typename std::underlying_type<T>::type;
|
||||
return LuaImplReplyVal(instance, static_cast<EnumT>(val), TypeTag<EnumT>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_enum<T>::value && IsEnumFlag<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<T>)
|
||||
{
|
||||
Flags<T> flags(val);
|
||||
return LuaImplReplyVal(instance, flags, TypeTag<decltype(flags)>());
|
||||
}
|
||||
|
||||
template<typename E>
|
||||
int LuaImplReplyVal(const LuaState& instance, Flags<E> val, TypeTag<Flags<E>>)
|
||||
{
|
||||
instance.PushInteger(typename Flags<E>::BitField(val));
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_integral<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<T>)
|
||||
{
|
||||
instance.PushInteger(val);
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<T&>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, val, TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<const T&>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, val, TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_enum<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<T&>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::move(val), TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_enum<T>::value, int> LuaImplReplyVal(const LuaState& instance, T val, TypeTag<const T&>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::move(val), TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
int LuaImplReplyVal(const LuaState& instance, T&& val, TypeTag<T&&>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::forward<T>(val), TypeTag<T>());
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, std::string&& val, TypeTag<std::string>)
|
||||
{
|
||||
instance.PushString(val.c_str(), val.size());
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, std::filesystem::path&& val, TypeTag<std::filesystem::path>)
|
||||
{
|
||||
return LuaImplReplyVal(instance, val.generic_u8string(), TypeTag<std::string>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline int LuaImplReplyVal(const LuaState& instance, std::vector<T>&& valContainer, TypeTag<std::vector<T>>)
|
||||
{
|
||||
std::size_t index = 1;
|
||||
instance.PushTable(valContainer.size());
|
||||
for (T& val : valContainer)
|
||||
{
|
||||
instance.PushInteger(index++);
|
||||
if (LuaImplReplyVal(instance, std::move(val), TypeTag<T>()) != 1)
|
||||
{
|
||||
instance.Error("Couldn't create table: type need more than one place to store");
|
||||
return 0;
|
||||
}
|
||||
instance.SetTable();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, ByteArray&& val, TypeTag<ByteArray>)
|
||||
{
|
||||
instance.PushString(reinterpret_cast<const char*>(val.GetConstBuffer()), val.GetSize());
|
||||
return 1;
|
||||
}
|
||||
|
||||
inline int LuaImplReplyVal(const LuaState& instance, String&& val, TypeTag<String>)
|
||||
{
|
||||
instance.PushString(std::move(val));
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T1, typename T2>
|
||||
int LuaImplReplyVal(const LuaState& instance, std::pair<T1, T2>&& val, TypeTag<std::pair<T1, T2>>)
|
||||
{
|
||||
int retVal = 0;
|
||||
|
||||
retVal += LuaImplReplyVal(instance, std::move(val.first), TypeTag<T1>());
|
||||
retVal += LuaImplReplyVal(instance, std::move(val.second), TypeTag<T2>());
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
template<bool HasDefault>
|
||||
struct LuaImplArgProcesser;
|
||||
|
||||
template<>
|
||||
struct LuaImplArgProcesser<true>
|
||||
{
|
||||
template<std::size_t N, std::size_t FirstDefArg, typename ArgType, typename ArgContainer, typename DefArgContainer>
|
||||
static unsigned int Process(const LuaState& instance, unsigned int argIndex, ArgContainer& args, DefArgContainer& defArgs)
|
||||
{
|
||||
return LuaImplQueryArg(instance, argIndex, &std::get<N>(args), std::get<FirstDefArg + std::tuple_size<DefArgContainer>() - N - 1>(defArgs), TypeTag<ArgType>());
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct LuaImplArgProcesser<false>
|
||||
{
|
||||
template<std::size_t N, std::size_t FirstDefArg, typename ArgType, typename ArgContainer, typename DefArgContainer>
|
||||
static unsigned int Process(const LuaState& instance, unsigned int argIndex, ArgContainer& args, DefArgContainer& defArgs)
|
||||
{
|
||||
NazaraUnused(defArgs);
|
||||
|
||||
return LuaImplQueryArg(instance, argIndex, &std::get<N>(args), TypeTag<ArgType>());
|
||||
}
|
||||
};
|
||||
|
||||
template<typename... Args>
|
||||
class LuaImplFunctionProxy
|
||||
{
|
||||
public:
|
||||
template<typename... DefArgs>
|
||||
class Impl
|
||||
{
|
||||
static constexpr std::size_t ArgCount = sizeof...(Args);
|
||||
static constexpr std::size_t DefArgCount = sizeof...(DefArgs);
|
||||
|
||||
static_assert(ArgCount >= DefArgCount, "There cannot be more default arguments than argument");
|
||||
|
||||
static constexpr std::size_t FirstDefArg = ArgCount - DefArgCount;
|
||||
|
||||
public:
|
||||
Impl(DefArgs... defArgs) :
|
||||
m_defaultArgs(std::forward<DefArgs>(defArgs)...)
|
||||
{
|
||||
}
|
||||
|
||||
void ProcessArguments(const LuaState& instance) const
|
||||
{
|
||||
m_index = 1;
|
||||
ProcessArgs<0, Args...>(instance);
|
||||
}
|
||||
|
||||
int Invoke(const LuaState& instance, void(*func)(Args...)) const
|
||||
{
|
||||
NazaraUnused(instance);
|
||||
|
||||
Apply(func, m_args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename Ret>
|
||||
int Invoke(const LuaState& instance, Ret(*func)(Args...)) const
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::move(Apply(func, m_args)), TypeTag<decltype(Apply(func, m_args))>());
|
||||
}
|
||||
|
||||
private:
|
||||
using ArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>;
|
||||
using DefArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<DefArgs>>...>;
|
||||
|
||||
template<std::size_t N>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
NazaraUnused(instance);
|
||||
|
||||
// No argument to process
|
||||
}
|
||||
|
||||
template<std::size_t N, typename ArgType>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
LuaImplArgProcesser<(N >= FirstDefArg)>::template Process<N, FirstDefArg, ArgType>(instance, m_index, m_args, m_defaultArgs);
|
||||
}
|
||||
|
||||
template<std::size_t N, typename ArgType1, typename ArgType2, typename... Rest>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
ProcessArgs<N, ArgType1>(instance);
|
||||
ProcessArgs<N + 1, ArgType2, Rest...>(instance);
|
||||
}
|
||||
|
||||
mutable ArgContainer m_args;
|
||||
DefArgContainer m_defaultArgs;
|
||||
mutable unsigned int m_index;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename... Args>
|
||||
class LuaImplMethodProxy
|
||||
{
|
||||
public:
|
||||
template<typename... DefArgs>
|
||||
class Impl
|
||||
{
|
||||
static constexpr std::size_t ArgCount = sizeof...(Args);
|
||||
static constexpr std::size_t DefArgCount = sizeof...(DefArgs);
|
||||
|
||||
static_assert(ArgCount >= DefArgCount, "There cannot be more default arguments than argument");
|
||||
|
||||
static constexpr std::size_t FirstDefArg = ArgCount - DefArgCount;
|
||||
|
||||
public:
|
||||
Impl(DefArgs... defArgs) :
|
||||
m_defaultArgs(std::forward<DefArgs>(defArgs)...)
|
||||
{
|
||||
}
|
||||
|
||||
void ProcessArguments(const LuaState& instance) const
|
||||
{
|
||||
m_index = 2; //< 1 being the instance
|
||||
ProcessArgs<0, Args...>(instance);
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, T& object, void(P::*func)(Args...)) const
|
||||
{
|
||||
NazaraUnused(instance);
|
||||
|
||||
Apply(object, func, m_args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename T, typename P, typename Ret>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, T& object, Ret(P::*func)(Args...)) const
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::move(Apply(object, func, m_args)), TypeTag<decltype(Apply(object, func, m_args))>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, T& object, T&(P::*func)(Args...)) const
|
||||
{
|
||||
T& r = Apply(object, func, m_args);
|
||||
if (&r == &object)
|
||||
{
|
||||
instance.PushValue(1); //< Userdata
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return LuaImplReplyVal(instance, r, TypeTag<T&>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, const T& object, void(P::*func)(Args...) const) const
|
||||
{
|
||||
NazaraUnused(instance);
|
||||
|
||||
Apply(object, func, m_args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename T, typename P, typename Ret>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, const T& object, Ret(P::*func)(Args...) const) const
|
||||
{
|
||||
return LuaImplReplyVal(instance, std::move(Apply(object, func, m_args)), TypeTag<decltype(Apply(object, func, m_args))>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaState& instance, const T& object, const T&(P::*func)(Args...) const) const
|
||||
{
|
||||
const T& r = Apply(object, func, m_args);
|
||||
if (&r == &object)
|
||||
{
|
||||
instance.PushValue(1); //< Userdata
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return LuaImplReplyVal(instance, r, TypeTag<T&>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, T& object, void(P::*func)(Args...)) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
Apply(*object, func, m_args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename T, typename P, typename Ret>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, T& object, Ret(P::*func)(Args...)) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return LuaImplReplyVal(instance, std::move(Apply(*object, func, m_args)), TypeTag<decltype(Apply(*object, func, m_args))>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, T& object, typename PointedType<T>::type&(P::*func)(Args...) const) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
const typename PointedType<T>::type& r = Apply(*object, func, m_args);
|
||||
if (&r == &*object)
|
||||
{
|
||||
instance.PushValue(1); //< Userdata
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return LuaImplReplyVal(instance, r, TypeTag<T&>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, const T& object, void(P::*func)(Args...) const) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
Apply(*object, func, m_args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename T, typename P, typename Ret>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, const T& object, Ret(P::*func)(Args...) const) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return LuaImplReplyVal(instance, std::move(Apply(*object, func, m_args)), TypeTag<decltype(Apply(*object, func, m_args))>());
|
||||
}
|
||||
|
||||
template<typename T, typename P>
|
||||
std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaState& instance, const T& object, const typename PointedType<T>::type&(P::*func)(Args...) const) const
|
||||
{
|
||||
if (!object)
|
||||
{
|
||||
instance.Error("Invalid object");
|
||||
return 0;
|
||||
}
|
||||
|
||||
const typename PointedType<T>::type& r = Apply(*object, func, m_args);
|
||||
if (&r == &*object)
|
||||
{
|
||||
instance.PushValue(1); //< Userdata
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return LuaImplReplyVal(instance, r, TypeTag<T&>());
|
||||
}
|
||||
|
||||
private:
|
||||
using ArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>;
|
||||
using DefArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<DefArgs>>...>;
|
||||
|
||||
template<std::size_t N>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
NazaraUnused(instance);
|
||||
|
||||
// No argument to process
|
||||
}
|
||||
|
||||
template<std::size_t N, typename ArgType>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
m_index += LuaImplArgProcesser<(N >= FirstDefArg)>::template Process<N, FirstDefArg, ArgType>(instance, m_index, m_args, m_defaultArgs);
|
||||
}
|
||||
|
||||
template<std::size_t N, typename ArgType1, typename ArgType2, typename... Rest>
|
||||
void ProcessArgs(const LuaState& instance) const
|
||||
{
|
||||
ProcessArgs<N, ArgType1>(instance);
|
||||
ProcessArgs<N + 1, ArgType2, Rest...>(instance);
|
||||
}
|
||||
|
||||
mutable ArgContainer m_args;
|
||||
DefArgContainer m_defaultArgs;
|
||||
mutable unsigned int m_index;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T LuaState::Check(int* index) const
|
||||
{
|
||||
NazaraAssert(index, "Invalid index pointer");
|
||||
|
||||
T object;
|
||||
*index += LuaImplQueryArg(*this, *index, &object, TypeTag<T>());
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::Check(int* index, T defValue) const
|
||||
{
|
||||
NazaraAssert(index, "Invalid index pointer");
|
||||
|
||||
T object;
|
||||
*index += LuaImplQueryArg(*this, *index, &object, defValue, TypeTag<T>());
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T LuaState::CheckBoundInteger(int index) const
|
||||
{
|
||||
return CheckBounds<T>(index, CheckInteger(index));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T LuaState::CheckBoundInteger(int index, T defValue) const
|
||||
{
|
||||
return CheckBounds<T>(index, CheckInteger(index, defValue));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckField(const char* fieldName, int tableIndex) const
|
||||
{
|
||||
T object;
|
||||
|
||||
GetField(fieldName, tableIndex);
|
||||
tableIndex += LuaImplQueryArg(*this, -1, &object, TypeTag<T>());
|
||||
Pop();
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckField(const String& fieldName, int tableIndex) const
|
||||
{
|
||||
return CheckField<T>(fieldName.GetConstBuffer(), tableIndex);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckField(const char* fieldName, T defValue, int tableIndex) const
|
||||
{
|
||||
T object;
|
||||
|
||||
GetField(fieldName, tableIndex);
|
||||
tableIndex += LuaImplQueryArg(*this, -1, &object, defValue, TypeTag<T>());
|
||||
Pop();
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckField(const String& fieldName, T defValue, int tableIndex) const
|
||||
{
|
||||
return CheckField<T>(fieldName.GetConstBuffer(), defValue, tableIndex);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckGlobal(const char* fieldName) const
|
||||
{
|
||||
T object;
|
||||
|
||||
GetGlobal(fieldName);
|
||||
LuaImplQueryArg(*this, -1, &object, TypeTag<T>());
|
||||
Pop();
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckGlobal(const String& fieldName) const
|
||||
{
|
||||
return CheckGlobal<T>(fieldName.GetConstBuffer());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckGlobal(const char* fieldName, T defValue) const
|
||||
{
|
||||
T object;
|
||||
|
||||
GetGlobal(fieldName);
|
||||
LuaImplQueryArg(*this, -1, &object, defValue, TypeTag<T>());
|
||||
Pop();
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T LuaState::CheckGlobal(const String& fieldName, T defValue) const
|
||||
{
|
||||
return CheckGlobal<T>(fieldName.GetConstBuffer(), defValue);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
int LuaState::Push(T arg) const
|
||||
{
|
||||
return LuaImplReplyVal(*this, std::move(arg), TypeTag<T>());
|
||||
}
|
||||
|
||||
template<typename T, typename T2, typename... Args>
|
||||
int LuaState::Push(T firstArg, T2 secondArg, Args... args) const
|
||||
{
|
||||
int valCount = 0;
|
||||
valCount += Push(std::move(firstArg));
|
||||
valCount += Push(secondArg, std::forward<Args>(args)...);
|
||||
|
||||
return valCount;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void LuaState::PushField(const char* name, T&& arg, int tableIndex) const
|
||||
{
|
||||
Push(std::forward<T>(arg));
|
||||
SetField(name, tableIndex);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void LuaState::PushField(const String& name, T&& arg, int tableIndex) const
|
||||
{
|
||||
PushField(name.GetConstBuffer(), std::forward<T>(arg), tableIndex);
|
||||
}
|
||||
|
||||
template<typename R, typename... Args, typename... DefArgs>
|
||||
void LuaState::PushFunction(R(*func)(Args...), DefArgs&&... defArgs) const
|
||||
{
|
||||
typename LuaImplFunctionProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
|
||||
|
||||
PushFunction([func, handler] (LuaState& lua) -> int
|
||||
{
|
||||
handler.ProcessArguments(lua);
|
||||
|
||||
return handler.Invoke(lua, func);
|
||||
});
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void LuaState::PushGlobal(const char* name, T&& arg)
|
||||
{
|
||||
Push(std::forward<T>(arg));
|
||||
SetGlobal(name);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void LuaState::PushGlobal(const String& name, T&& arg)
|
||||
{
|
||||
PushGlobal(name.GetConstBuffer(), std::forward<T>(arg));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void LuaState::PushInstance(const char* tname, T&& instance) const
|
||||
{
|
||||
T* userdata = static_cast<T*>(PushUserdata(sizeof(T)));
|
||||
PlacementNew(userdata, std::move(instance));
|
||||
|
||||
SetMetatable(tname);
|
||||
}
|
||||
|
||||
template<typename T, typename... Args>
|
||||
void LuaState::PushInstance(const char* tname, Args&&... args) const
|
||||
{
|
||||
T* userdata = static_cast<T*>(PushUserdata(sizeof(T)));
|
||||
PlacementNew(userdata, std::forward<Args>(args)...);
|
||||
|
||||
SetMetatable(tname);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_signed<T>::value, T> LuaState::CheckBounds(int index, long long value) const
|
||||
{
|
||||
constexpr long long minBounds = std::numeric_limits<T>::min();
|
||||
constexpr long long maxBounds = std::numeric_limits<T>::max();
|
||||
if (value < minBounds || value > maxBounds)
|
||||
{
|
||||
Nz::StringStream stream;
|
||||
stream << "Argument #" << index << " is outside value range [" << minBounds << ", " << maxBounds << "] (" << value << ')';
|
||||
Error(stream);
|
||||
}
|
||||
|
||||
return static_cast<T>(value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::enable_if_t<std::is_unsigned<T>::value, T> LuaState::CheckBounds(int index, long long value) const
|
||||
{
|
||||
unsigned long long uValue = static_cast<unsigned long long>(value);
|
||||
constexpr unsigned long long minBounds = 0;
|
||||
constexpr unsigned long long maxBounds = std::numeric_limits<T>::max();
|
||||
if (uValue < minBounds || uValue > maxBounds)
|
||||
{
|
||||
Nz::StringStream stream;
|
||||
stream << "Argument #" << index << " is outside value range [" << minBounds << ", " << maxBounds << "] (" << value << ')';
|
||||
Error(stream);
|
||||
}
|
||||
|
||||
return static_cast<T>(uValue);
|
||||
}
|
||||
|
||||
inline LuaState LuaState::GetState(lua_State* internalState)
|
||||
{
|
||||
return LuaState(internalState);
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
// This file was automatically generated
|
||||
|
||||
/*
|
||||
Nazara Engine - Noise module
|
||||
|
||||
Copyright (C) 2016 Rémi "Overdrivr" Bèges (remi.beges@laposte.net)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_GLOBAL_NOISE_HPP
|
||||
#define NAZARA_GLOBAL_NOISE_HPP
|
||||
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#include <Nazara/Noise/Enums.hpp>
|
||||
#include <Nazara/Noise/FBM.hpp>
|
||||
#include <Nazara/Noise/HybridMultiFractal.hpp>
|
||||
#include <Nazara/Noise/MixerBase.hpp>
|
||||
#include <Nazara/Noise/Noise.hpp>
|
||||
#include <Nazara/Noise/NoiseBase.hpp>
|
||||
#include <Nazara/Noise/NoiseTools.hpp>
|
||||
#include <Nazara/Noise/Perlin.hpp>
|
||||
#include <Nazara/Noise/Simplex.hpp>
|
||||
#include <Nazara/Noise/Worley.hpp>
|
||||
|
||||
#endif // NAZARA_GLOBAL_NOISE_HPP
|
||||
@@ -1,51 +0,0 @@
|
||||
/*
|
||||
Nazara Engine - Noise module
|
||||
|
||||
Copyright (C) 2016 Rémi "Overdrivr" Bèges (remi.beges@laposte.net)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_CONFIG_NOISE_HPP
|
||||
#define NAZARA_CONFIG_NOISE_HPP
|
||||
|
||||
/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci
|
||||
|
||||
// Utilise un manager de mémoire pour gérer les allocations dynamiques (détecte les leaks au prix d'allocations/libérations dynamiques plus lentes)
|
||||
#define NAZARA_NOISE_MANAGE_MEMORY 0
|
||||
|
||||
// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
|
||||
#define NAZARA_NOISE_SAFE 1
|
||||
|
||||
/// Vérification des valeurs et types de certaines constantes
|
||||
#include <Nazara/Noise/ConfigCheck.hpp>
|
||||
|
||||
#if defined(NAZARA_STATIC)
|
||||
#define NAZARA_NOISE_API
|
||||
#else
|
||||
#ifdef NAZARA_NOISE_BUILD
|
||||
#define NAZARA_NOISE_API NAZARA_EXPORT
|
||||
#else
|
||||
#define NAZARA_NOISE_API NAZARA_IMPORT
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif // NAZARA_CONFIG_MODULENAME_HPP
|
||||
@@ -1,18 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_CONFIG_CHECK_NOISE_HPP
|
||||
#define NAZARA_CONFIG_CHECK_NOISE_HPP
|
||||
|
||||
/// Ce fichier sert à vérifier la valeur des constantes du fichier Config.hpp
|
||||
|
||||
// On force la valeur de MANAGE_MEMORY en mode debug
|
||||
#if defined(NAZARA_DEBUG) && !NAZARA_NOISE_MANAGE_MEMORY
|
||||
#undef NAZARA_NOISE_MANAGE_MEMORY
|
||||
#define NAZARA_NOISE_MANAGE_MEMORY 0
|
||||
#endif
|
||||
|
||||
#endif // NAZARA_CONFIG_CHECK_NOISE_HPP
|
||||
@@ -1,8 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#if NAZARA_NOISE_MANAGE_MEMORY
|
||||
#include <Nazara/Core/Debug/NewRedefinition.hpp>
|
||||
#endif
|
||||
@@ -1,9 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
// On suppose que Debug.hpp a déjà été inclus, tout comme Config.hpp
|
||||
#if NAZARA_NOISE_MANAGE_MEMORY
|
||||
#undef delete
|
||||
#undef new
|
||||
#endif
|
||||
@@ -1,18 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_ENUMS_NOISE_HPP
|
||||
#define NAZARA_ENUMS_NOISE_HPP
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
enum WorleyFunction
|
||||
{
|
||||
WorleyFunction_F1 = 0,
|
||||
WorleyFunction_F2 = 1,
|
||||
WorleyFunction_F3 = 2,
|
||||
WorleyFunction_F4 = 3
|
||||
};
|
||||
}
|
||||
#endif // NAZARA_ENUMS_NOISE_HPP
|
||||
@@ -1,31 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_FBM_HPP
|
||||
#define NAZARA_FBM_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/MixerBase.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API FBM : public MixerBase
|
||||
{
|
||||
public:
|
||||
FBM(const NoiseBase& source);
|
||||
FBM(const FBM&) = delete;
|
||||
~FBM() = default;
|
||||
|
||||
float Get(float x, float y, float scale) const override;
|
||||
float Get(float x, float y, float z, float scale) const override;
|
||||
float Get(float x, float y, float z, float w, float scale) const override;
|
||||
|
||||
FBM& operator=(const FBM&) = delete;
|
||||
|
||||
private:
|
||||
const NoiseBase& m_source;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_FBM_HPP
|
||||
@@ -1,31 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_HYBRIDMULTIFRACTAL_HPP
|
||||
#define NAZARA_HYBRIDMULTIFRACTAL_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/MixerBase.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API HybridMultiFractal : public MixerBase
|
||||
{
|
||||
public:
|
||||
HybridMultiFractal(const NoiseBase & source);
|
||||
HybridMultiFractal(const HybridMultiFractal&) = delete;
|
||||
~HybridMultiFractal() = default;
|
||||
|
||||
float Get(float x, float y, float scale) const override;
|
||||
float Get(float x, float y, float z, float scale) const override;
|
||||
float Get(float x, float y, float z, float w, float scale) const override;
|
||||
|
||||
HybridMultiFractal& operator=(const HybridMultiFractal&) = delete;
|
||||
|
||||
private:
|
||||
const NoiseBase& m_source;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_HYBRIDMULTIFRACTAL_HPP
|
||||
@@ -1,41 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_MIXERBASE_HPP
|
||||
#define NAZARA_MIXERBASE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/NoiseBase.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API MixerBase
|
||||
{
|
||||
public:
|
||||
MixerBase();
|
||||
virtual ~MixerBase() = default;
|
||||
|
||||
virtual float Get(float x, float y, float scale) const = 0;
|
||||
virtual float Get(float x, float y, float z, float scale) const = 0;
|
||||
virtual float Get(float x, float y, float z, float w, float scale) const = 0;
|
||||
|
||||
float GetHurstParameter() const;
|
||||
float GetLacunarity() const;
|
||||
float GetOctaveNumber() const;
|
||||
|
||||
void SetParameters(float hurst, float lacunarity, float octaves);
|
||||
|
||||
protected:
|
||||
float m_hurst;
|
||||
float m_lacunarity;
|
||||
float m_octaves;
|
||||
std::vector<float> m_exponent_array;
|
||||
float m_sum;
|
||||
|
||||
private:
|
||||
void Recompute();
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_MIXERBASE_HPP
|
||||
@@ -1,32 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef NAZARA_NOISE_HPP
|
||||
#define NAZARA_NOISE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API Noise
|
||||
{
|
||||
public:
|
||||
Noise() = delete;
|
||||
~Noise() = delete;
|
||||
|
||||
static bool Initialize();
|
||||
|
||||
static bool IsInitialized();
|
||||
|
||||
static void Uninitialize();
|
||||
|
||||
private:
|
||||
static unsigned int s_moduleReferenceCounter;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_NOISE_HPP
|
||||
@@ -1,47 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_NOISEBASE_HPP
|
||||
#define NAZARA_NOISEBASE_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Math/Vector2.hpp>
|
||||
#include <Nazara/Math/Vector3.hpp>
|
||||
#include <Nazara/Math/Vector4.hpp>
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#include <array>
|
||||
#include <random>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API NoiseBase
|
||||
{
|
||||
public:
|
||||
NoiseBase(unsigned int seed = 0);
|
||||
virtual ~NoiseBase() = default;
|
||||
|
||||
virtual float Get(float x, float y, float scale) const = 0;
|
||||
virtual float Get(float x, float y, float z, float scale) const = 0;
|
||||
virtual float Get(float x, float y, float z, float w, float scale) const = 0;
|
||||
float GetScale();
|
||||
|
||||
void SetScale(float scale);
|
||||
void SetSeed(unsigned int seed);
|
||||
|
||||
void Shuffle();
|
||||
|
||||
protected:
|
||||
std::array<std::size_t, 3 * 256> m_permutations;
|
||||
float m_scale;
|
||||
|
||||
static std::array<Vector2f, 2 * 2 * 2> s_gradients2;
|
||||
static std::array<Vector3f, 2 * 2 * 2 * 2> s_gradients3;
|
||||
static std::array<Vector4f, 2 * 2 * 2 * 2 * 2> s_gradients4;
|
||||
|
||||
private:
|
||||
std::mt19937 m_randomEngine;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_NOISEBASE_HPP
|
||||
@@ -1,14 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_NOISETOOLS_HPP
|
||||
#define NAZARA_NOISETOOLS_HPP
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
int fastfloor(float n);
|
||||
int JenkinsHash(int a, int b, int c);
|
||||
}
|
||||
|
||||
#endif // NAZARA_NOISETOOLS_HPP
|
||||
@@ -1,27 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_PERLIN_HPP
|
||||
#define NAZARA_PERLIN_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#include <Nazara/Noise/NoiseBase.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API Perlin : public NoiseBase
|
||||
{
|
||||
public:
|
||||
Perlin() = default;
|
||||
Perlin(unsigned int seed);
|
||||
~Perlin() = default;
|
||||
|
||||
float Get(float x, float y, float scale) const override;
|
||||
float Get(float x, float y, float z, float scale) const override;
|
||||
float Get(float x, float y, float z, float w, float scale) const override;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_PERLIN_HPP
|
||||
@@ -1,27 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_SIMPLEX_HPP
|
||||
#define NAZARA_SIMPLEX_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#include <Nazara/Noise/NoiseBase.hpp>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API Simplex : public NoiseBase
|
||||
{
|
||||
public:
|
||||
Simplex() = default;
|
||||
Simplex(unsigned int seed);
|
||||
~Simplex() = default;
|
||||
|
||||
float Get(float x, float y, float scale) const override;
|
||||
float Get(float x, float y, float z, float scale) const override;
|
||||
float Get(float x, float y, float z, float w, float scale) const override;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_SIMPLEX_HPP
|
||||
@@ -1,37 +0,0 @@
|
||||
// Copyright (C) 2017 Rémi Bèges
|
||||
// This file is part of the "Nazara Engine - Noise module"
|
||||
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||
|
||||
#ifndef NAZARA_WORLEY_HPP
|
||||
#define NAZARA_WORLEY_HPP
|
||||
|
||||
#include <Nazara/Prerequisites.hpp>
|
||||
#include <Nazara/Math/Vector2.hpp>
|
||||
#include <Nazara/Noise/Config.hpp>
|
||||
#include <Nazara/Noise/Enums.hpp>
|
||||
#include <Nazara/Noise/NoiseBase.hpp>
|
||||
#include <map>
|
||||
|
||||
namespace Nz
|
||||
{
|
||||
class NAZARA_NOISE_API Worley : public NoiseBase
|
||||
{
|
||||
public:
|
||||
Worley();
|
||||
Worley(unsigned int seed);
|
||||
~Worley() = default;
|
||||
|
||||
float Get(float x, float y, float scale) const override;
|
||||
float Get(float x, float y, float z, float scale) const override;
|
||||
float Get(float x, float y, float z, float w, float scale) const override;
|
||||
|
||||
void Set(WorleyFunction func);
|
||||
|
||||
private:
|
||||
void SquareTest(int xi, int yi, float x, float y, std::map<float, Vector2f> & featurePoints) const;
|
||||
|
||||
WorleyFunction m_function;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // NAZARA_WORLEY_HPP
|
||||
Reference in New Issue
Block a user