MINOR: Added Frameworks for Debugger

Author: JailbreakPapa

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Code/ThirdParty/JoltPhysics"]
+	path = Code/ThirdParty/JoltPhysics
+	url = https://github.com/jrouwe/JoltPhysics.git

Code/BuildSystem/CMake/CMakeUtils/nsUtilsVulkan.cmake

@@ -1,8 +1,8 @@
 # #####################################
 # ## Vulkan support
 # #####################################
-
-set(NS_BUILD_EXPERIMENTAL_VULKAN OFF CACHE BOOL "Whether to enable experimental / work-in-progress Vulkan code")
+# NOTE: Forcing Vulkan on since JDebug Must be Cross-Platform.
+set(NS_BUILD_EXPERIMENTAL_VULKAN ON CACHE BOOL "Whether to enable experimental / work-in-progress Vulkan code")
 
 # #####################################
 # ## ns_requires_vulkan()

Code/Core/CMakeLists.txt

@@ -0,0 +1,43 @@
+ns_cmake_init()
+
+
+
+# Get the name of this folder as the project name
+get_filename_component(PROJECT_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE)
+
+ns_create_target(LIBRARY ${PROJECT_NAME})
+
+ns_enable_strict_warnings(${PROJECT_NAME})
+
+target_link_libraries(${PROJECT_NAME}
+  PUBLIC
+  Foundation
+  Texture
+
+  PRIVATE
+  mikktspace
+)
+
+if (NS_3RDPARTY_LUA_SUPPORT)
+
+  target_link_libraries(${PROJECT_NAME}
+    PUBLIC
+    Lua
+  )
+
+endif()
+
+if (NS_3RDPARTY_DUKTAPE_SUPPORT)
+
+  target_link_libraries(${PROJECT_NAME}
+    PUBLIC
+    Duktape
+  )
+
+endif()
+
+if(NS_3RDPARTY_GLFW_SUPPORT)
+
+  target_link_libraries(${PROJECT_NAME} PRIVATE glfw)
+
+endif()

Code/Core/Console/Console.h

@@ -0,0 +1,179 @@
+#pragma once
+
+#include <Core/Console/ConsoleFunction.h>
+#include <Foundation/Communication/Event.h>
+#include <Foundation/Configuration/CVar.h>
+#include <Foundation/Containers/Deque.h>
+#include <Foundation/Containers/Map.h>
+#include <Foundation/Containers/StaticArray.h>
+#include <Foundation/Strings/StringBuilder.h>
+#include <Foundation/Threading/Mutex.h>
+#include <Foundation/Types/RefCounted.h>
+#include <Foundation/Types/SharedPtr.h>
+
+struct NS_CORE_DLL nsConsoleString
+{
+  enum class Type : nsUInt8
+  {
+    Default,
+    Error,
+    SeriousWarning,
+    Warning,
+    Note,
+    Success,
+    Executed,
+    VarName,
+    FuncName,
+    Dev,
+    Debug,
+  };
+
+  Type m_Type = Type::Default;
+  nsString m_sText;
+  nsColor GetColor() const;
+
+  bool operator<(const nsConsoleString& rhs) const { return m_sText < rhs.m_sText; }
+};
+
+struct NS_CORE_DLL nsCommandInterpreterState
+{
+  nsStringBuilder m_sInput;
+  nsHybridArray<nsConsoleString, 16> m_sOutput;
+
+  void AddOutputLine(const nsFormatString& text, nsConsoleString::Type type = nsConsoleString::Type::Default);
+};
+
+class NS_CORE_DLL nsCommandInterpreter : public nsRefCounted
+{
+public:
+  virtual void Interpret(nsCommandInterpreterState& inout_state) = 0;
+
+  virtual void AutoComplete(nsCommandInterpreterState& inout_state);
+
+  /// \brief Iterates over all cvars and finds all that start with the string \a szVariable.
+  static void FindPossibleCVars(nsStringView sVariable, nsDeque<nsString>& ref_commonStrings, nsDeque<nsConsoleString>& ref_consoleStrings);
+
+  /// \brief Iterates over all console functions and finds all that start with the string \a szVariable.
+  static void FindPossibleFunctions(nsStringView sVariable, nsDeque<nsString>& ref_commonStrings, nsDeque<nsConsoleString>& ref_consoleStrings);
+
+  /// \brief Returns the prefix string that is common to all strings in the \a vStrings array.
+  static const nsString FindCommonString(const nsDeque<nsString>& strings);
+};
+
+/// \brief The event data that is broadcast by the console
+struct nsConsoleEvent
+{
+  enum class Type : nsInt32
+  {
+    OutputLineAdded, ///< A string was added to the console
+  };
+
+  Type m_Type;
+
+  /// \brief The console string that was just added.
+  const nsConsoleString* m_AddedpConsoleString;
+};
+
+class NS_CORE_DLL nsConsole
+{
+public:
+  nsConsole();
+  virtual ~nsConsole();
+
+  /// \name Events
+  /// @{
+
+public:
+  /// \brief Grants access to subscribe and unsubscribe from console events.
+  const nsEvent<const nsConsoleEvent&>& Events() const { return m_Events; }
+
+protected:
+  /// \brief The console event variable, to attach to.
+  nsEvent<const nsConsoleEvent&> m_Events;
+
+  /// @}
+
+  /// \name Helpers
+  /// @{
+
+public:
+  /// \brief Returns the mutex that's used to prevent multi-threaded access
+  nsMutex& GetMutex() const { return m_Mutex; }
+
+  static void SetMainConsole(nsConsole* pConsole);
+  static nsConsole* GetMainConsole();
+
+protected:
+  mutable nsMutex m_Mutex;
+
+private:
+  static nsConsole* s_pMainConsole;
+
+  /// @}
+
+  /// \name Command Interpreter
+  /// @{
+
+public:
+  /// \brief Replaces the current command interpreter.
+  ///
+  /// This base class doesn't set any default interpreter, but derived classes may do so.
+  void SetCommandInterpreter(const nsSharedPtr<nsCommandInterpreter>& pInterpreter) { m_pCommandInterpreter = pInterpreter; }
+
+  /// \brief Returns the currently used command interpreter.
+  const nsSharedPtr<nsCommandInterpreter>& GetCommandInterpreter() const { return m_pCommandInterpreter; }
+
+  /// \brief Auto-completes the given text.
+  ///
+  /// Returns true, if the string was modified in any way.
+  /// Adds additional strings to the console output, if there are further auto-completion suggestions.
+  virtual bool AutoComplete(nsStringBuilder& ref_sText);
+
+  /// \brief Executes the given input string.
+  ///
+  /// The command is forwarded to the set command interpreter.
+  virtual void ExecuteCommand(nsStringView sInput);
+
+protected:
+  nsSharedPtr<nsCommandInterpreter> m_pCommandInterpreter;
+
+  /// @}
+
+  /// \name Console Display
+  /// @{
+
+public:
+  /// \brief Adds a string to the console.
+  ///
+  /// The base class only broadcasts an event, but does not store the string anywhere.
+  virtual void AddConsoleString(nsStringView sText, nsConsoleString::Type type = nsConsoleString::Type::Default);
+
+  /// @}
+
+  /// \name Input History
+  /// @{
+
+public:
+  /// \brief Adds an item to the input history.
+  void AddToInputHistory(nsStringView sText);
+
+  /// \brief Returns the current input history.
+  ///
+  /// Make sure to lock the console's mutex while working with the history.
+  const nsStaticArray<nsString, 16>& GetInputHistory() const { return m_InputHistory; }
+
+  /// \brief Replaces the input line by the next (or previous) history item.
+  void RetrieveInputHistory(nsInt32 iHistoryUp, nsStringBuilder& ref_sResult);
+
+  /// \brief Writes the current input history to a text file.
+  nsResult SaveInputHistory(nsStringView sFile);
+
+  /// \brief Reads the text file and appends all lines to the input history.
+  void LoadInputHistory(nsStringView sFile);
+
+protected:
+  nsInt32 m_iCurrentInputHistoryElement = -1;
+  nsStaticArray<nsString, 16> m_InputHistory;
+
+  /// @}
+};

Code/Core/Console/ConsoleFunction.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <Core/CoreDLL.h>
+#include <Foundation/Types/Delegate.h>
+#include <Foundation/Types/Variant.h>
+#include <Foundation/Utilities/EnumerableClass.h>
+
+/// \brief Base class for all types of nsConsoleFunction, represents functions to be exposed to nsConsole.
+///
+/// Console functions are similar to nsCVar's in that they can be executed from the nsConsole.
+/// A console function can wrap many different types of functions with differing number and types of parameters.
+/// nsConsoleFunction uses an nsDelegate internally to store the function reference, so even member functions would be possible.
+///
+/// All console functions are enumerable, as their base class nsConsoleFunctionBase is an nsEnumerable class.
+///
+/// Console functions can have between zero and six parameters. The LuaInterpreter for nsConsole only supports parameter types
+/// (unsigned) int, float/double, bool and string and uses the conversion feature of nsVariant to map the lua input to the final function.
+///
+/// To make a function available as a console function, create a global variable of type nsConsoleFunction with the proper template
+/// arguments to mirror its parameters and return type.
+/// Note that although functions with return types are accepted, the return value is currently always ignored.
+///
+/// \code{.cpp}
+///   void MyConsoleFunc1(int a, float b, nsStringView sz) { ... }
+///   nsConsoleFunction<void ()> ConFunc_MyConsoleFunc1("MyConsoleFunc1", "()", MyConsoleFunc1);
+///
+///   int MyConsoleFunc2(int a, float b, nsStringView sz) { ... }
+///   nsConsoleFunction<int (int, float, nsString)> ConFunc_MyConsoleFunc2("MyConsoleFunc2", "(int a, float b, string c)", MyConsoleFunc2);
+/// \endcode
+///
+/// Here the global function MyConsoleFunc2 is exposed to the console. The return value type and parameter types are passed as template
+/// arguments. ConFunc_MyConsoleFunc2 is now the global variable that represents the function for the console.
+/// The first string is the name with which the function is exposed, which is also used for auto-completion.
+/// The second string is the description of the function. Here we inserted the parameter list with types, so that the user knows how to
+/// use it. Finally the last parameter is the actual function to expose.
+class NS_CORE_DLL nsConsoleFunctionBase : public nsEnumerable<nsConsoleFunctionBase>
+{
+  NS_DECLARE_ENUMERABLE_CLASS(nsConsoleFunctionBase);
+
+public:
+  /// \brief The constructor takes the function name and description as it should appear in the console.
+  nsConsoleFunctionBase(nsStringView sFunctionName, nsStringView sDescription)
+    : m_sFunctionName(sFunctionName)
+    , m_sDescription(sDescription)
+  {
+  }
+
+  /// \brief Returns the name of the function as it should be exposed in the console.
+  nsStringView GetName() const { return m_sFunctionName; }
+
+  /// \brief Returns the description of the function as it should appear in the console.
+  nsStringView GetDescription() const { return m_sDescription; }
+
+  /// \brief Returns the number of parameters that this function takes.
+  virtual nsUInt32 GetNumParameters() const = 0;
+
+  /// \brief Returns the type of the n-th parameter.
+  virtual nsVariant::Type::Enum GetParameterType(nsUInt32 uiParam) const = 0;
+
+  /// \brief Calls the function. Each parameter must be put into an nsVariant and all of them are passed along as an array.
+  ///
+  /// Returns NS_FAILURE, if the number of parameters did not match, or any parameter was not convertible to the actual type that
+  /// the function expects.
+  virtual nsResult Call(nsArrayPtr<nsVariant> params) = 0;
+
+private:
+  nsStringView m_sFunctionName;
+  nsStringView m_sDescription;
+};
+
+
+/// \brief Implements the functionality of nsConsoleFunctionBase for functions with different parameter types. See nsConsoleFunctionBase for more
+/// details.
+template <typename R>
+class nsConsoleFunction : public nsConsoleFunctionBase
+{
+};
+
+
+#define ARG_COUNT 0
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 1
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 2
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 3
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 4
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 5
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT
+
+#define ARG_COUNT 6
+#include <Core/Console/Implementation/ConsoleFunctionHelper_inl.h>
+#undef ARG_COUNT