plugin loading

CMakeLists.txt

@@ -48,8 +48,8 @@ add_compile_definitions(
 )
 
 add_subdirectory(include)
-add_subdirectory(src/mc)
-add_subdirectory(src/client)
+add_subdirectory(src)
+add_subdirectory(test)
 
 if (MSVC)
     add_compile_options(/W4 /permissive- /wd4201 /wd4324)

README.md

@@ -12,9 +12,8 @@ Selaura Client
 This repository contains the full source code for Selaura Client. Selaura Client is a mod that aims to improve user experience of Minecraft: Bedrock Edition.
 
 ## 🖥️ Compatibility
-Selaura Client currently supports:
+Selaura Client aims to support:
 - Windows 10/11 (64-bit Only)
-- Xbox (requires Dev Mode and installation of DLL within Minecraft's files)
 - Android 9+ (ARM64 Only)
 - Any device supporting [mcpelauncher-linux](https://github.com/minecraft-linux/mcpelauncher-manifest)
 
@@ -24,8 +23,6 @@ Selaura Client currently supports:
 - [foonathan/type_safe](https://github.com/foonathan/type_safe)
 - [BasedInc/libhat](https://github.com/BasedInc/libhat)
 - [Neargye/magic_enum](https://github.com/Neargye/magic_enum)
-- [kunitoki/LuaBridge3](https://github.com/kunitoki/LuaBridge3)
-- [Sinan-Karakaya/cpp-i18n](https://github.com/Sinan-Karakaya/cpp-i18n)
 - [g-truc/glm](https://github.com/g-truc/glm)
 - [ocornut/imgui](https://github.com/ocornut/imgui)
 

src/client/CMakeLists.txt → src/CMakeLists.txt

@@ -2,12 +2,9 @@ cmake_minimum_required(VERSION 3.28)
 project(selaura_client LANGUAGES CXX)
 
 add_library(selaura_client SHARED
-        dllmain.cpp
-        components/client.cpp
-        memory/scanner.cpp
-        memory/scan_target.cpp
-        memory/handle.cpp
-        patches/patch_manager.cpp
+        loader/main_win.cpp
+        loader/runtime.cpp
+        hooks/hooks.cpp
 )
 
 target_include_directories(selaura_client PRIVATE
@@ -20,6 +17,8 @@ target_include_directories(selaura_client PRIVATE
         safetyhook
         glaze
         magic_enum
+
+        ${CMAKE_SOURCE_DIR}/src
 )
 
 target_link_libraries(selaura_client PRIVATE
@@ -31,4 +30,5 @@ target_link_libraries(selaura_client PRIVATE
         safetyhook::safetyhook
         glaze::glaze
         magic_enum::magic_enum
+        runtimeobject.lib
 )

src/api/helpers/mcuirc.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include <api/mc/client/renderer/MinecraftUIRenderContext.hpp>
+#include <glm/glm.hpp>
+#include <concepts>
+
+namespace selaura {
+    struct mcuirc {
+        MinecraftUIRenderContext* ctx;
+        explicit mcuirc(MinecraftUIRenderContext* _ctx) noexcept : ctx(_ctx) {}
+
+        void draw_rect(float x, float y, float width, float height,
+                       const glm::vec4& color,
+                       bool stroke = false, int stroke_width = 1) const noexcept {
+            const RectangleArea area{x, x + width, y, y + height};
+            const mce::Color c{color.x, color.y, color.z, color.w};
+
+            if (stroke) {
+                ctx->drawRectangle(area, c, color.z, stroke_width);
+            }
+            else {
+                ctx->fillRectangle(area, c, color.w);
+            }
+        }
+
+        void draw_rect(const glm::vec2& pos, const glm::vec2& size,
+                       const glm::vec4& color,
+                       bool stroke = false, int stroke_width = 1) const noexcept {
+            draw_rect(pos.x, pos.y, size.x, size.y, color, stroke, stroke_width);
+        }
+
+        void fill_rect(const glm::vec2& pos, const glm::vec2& size, const glm::vec4& color) const noexcept {
+            draw_rect(pos, size, color, false);
+        }
+
+        void stroke_rect(const glm::vec2& pos, const glm::vec2& size, const glm::vec4& color, int width = 1) const noexcept {
+            draw_rect(pos, size, color, true, width);
+        }
+
+        void draw_rect(const glm::vec4& rect, const glm::vec4& color,
+                       bool stroke = false, int stroke_width = 1) const noexcept {
+            draw_rect(rect.x, rect.y, rect.z, rect.w, color, stroke, stroke_width);
+        }
+    };
+
+}

src/api/imports.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef _WIN32
+#define MCAPI extern "C" __declspec(dllimport)
+#define SELAURA_API extern "C" __declspec(dllexport)
+#else
+#define SELAURA_API extern "C" __attribute__((visibility("default")))
+#endif
+
+#include <entt/entt.hpp>
+#include <glm/glm.hpp>
+
+#include <string>

src/api/mc/client/ClientInstance.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <api/mc/client/gui/GuiData.hpp>
+
+class ClientInstance {
+public:
+    uintptr_t** vtable;
+    std::byte pad_4[1080];
+    std::unique_ptr<GuiData> mGuiData;
+public:
+    void* $ctor(
+        void* a1,
+        void* a2,
+        void* a3,
+        void* a4,
+        void* a5,
+        void* a6,
+        void* a7,
+        void* a8,
+        void* a9
+    );
+};

src/api/mc/client/gui/GuiData.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <string>
+
+class GuiData {
+public:
+    void displayLocalMessage(const std::string& message);
+};

src/api/mc/client/gui/ScreenView.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <api/mc/client/renderer/MinecraftUIRenderContext.hpp>
+
+class ScreenView {
+public:
+    void setupAndRender(MinecraftUIRenderContext&);
+public:
+    void setupAndRender_hk(MinecraftUIRenderContext* ctx);
+};

src/api/mc/client/renderer/MinecraftUIRenderContext.hpp

@@ -0,0 +1,129 @@
+#pragma once
+#include <cstdint>
+#include <glm/glm.hpp>
+#include <gsl/gsl>
+
+#include <api/mc/client/ClientInstance.hpp>
+
+#pragma pack(push, 4)
+struct RectangleArea {
+    float _x0;
+    float _x1;
+    float _y0;
+    float _y1;
+};
+#pragma pack(pop)
+
+namespace mce {
+    class Color {
+    public:
+        float r;
+        float g;
+        float b;
+        float a;
+
+        Color(float r, float g, float b, float a)
+        {
+            this->r = r;
+            this->g = g;
+            this->b = b;
+            this->a = a;
+        }
+
+        Color(unsigned int color)
+        {
+            this->r = (float)((color & 0xFF000000) >> 24) / 255.0f;
+            this->g = (float)((color & 0x00FF0000) >> 16) / 255.0f;
+            this->b = (float)((color & 0x0000FF00) >> 8) / 255.0f;
+            this->a = (float)((color & 0x000000FF)) / 255.0f;
+        }
+
+        Color()
+        {
+            this->r = 0.0f;
+            this->g = 0.0f;
+            this->b = 0.0f;
+            this->a = 0.0f;
+        }
+
+        uint32_t As32() const
+        {
+            struct PackedColors {
+                union {
+                    struct {
+                        char r;
+                        char g;
+                        char b;
+                        char a;
+                    };
+                    unsigned int intValue;
+                };
+            };
+
+            PackedColors result{};
+            result.r = static_cast<char>(this->r * 255.0f);
+            result.g = static_cast<char>(this->g * 255.0f);
+            result.b = static_cast<char>(this->b * 255.0f);
+            result.a = static_cast<char>(this->a * 255.0f);
+
+            return result.intValue;
+        }
+    };
+
+    class TexturePtr;
+};
+
+class Font;
+class NinesliceInfo;
+class HashedString;
+class ComponentRenderBatch;
+class CustomRenderComponent;
+class ResourceLocation;
+
+namespace Core {
+    class Path;
+};
+
+class TextMeasureData;
+class CaretMeasureData;
+
+namespace ui {
+    class TextAlignment;
+};
+
+class MinecraftUIRenderContext {
+public:
+    MinecraftUIRenderContext(ClientInstance& client, void* screenContext, void* currentScene);
+    virtual ~MinecraftUIRenderContext();
+    virtual float getLineLength(Font& font, const std::string& text, float fontSize, bool showColorSymbol);
+    virtual float getTextAlpha();
+    virtual void setTextAlpha(float alpha);
+    virtual void drawDebugText(const RectangleArea& rect, const std::string& text, const mce::Color& color, float alpha, ui::TextAlignment alignment, const TextMeasureData& textData, const CaretMeasureData& caretData);
+    virtual void drawText(Font& font, const RectangleArea& rect, const std::string& text, const mce::Color& color, float alpha, ui::TextAlignment alignment, const TextMeasureData& textData, const CaretMeasureData& caretData);
+    virtual void flushText(float deltaTime);
+    virtual void drawImage(const mce::TexturePtr& texture, const glm::tvec2<float>& position, const glm::tvec2<float>& size, glm::tvec2<float>& uv, glm::tvec2<float>& uvSize, int degree);
+    virtual void drawNineslice(const mce::TexturePtr& texture, const NinesliceInfo& nineslice);
+    virtual void flushImages(const mce::Color& color, float alpha, const HashedString& materialNameHash);
+    virtual void beginSharedMeshBatch(ComponentRenderBatch& renderBatch);
+    virtual void endSharedMeshBatch(ComponentRenderBatch& renderBatch);
+    virtual void drawRectangle(const RectangleArea& rect, const mce::Color& color, float alpha, int thickness);
+    virtual void fillRectangle(const RectangleArea& rect, const mce::Color& color, float alpha);
+    virtual void increaseStencilRef();
+    virtual void decreaseStencilRef();
+    virtual void resetStencilRef();
+    virtual void fillRectangleStencil(const RectangleArea& rect);
+    virtual void enableScissorTest(const RectangleArea& rect);
+    virtual void disableScissorTest();
+    virtual void setClippingRectangle(const RectangleArea& rect);
+    virtual void setFullClippingRectangle();
+    virtual void saveCurrentClippingRectangle();
+    virtual void restoreSavedClippingRectangle();
+    virtual RectangleArea getFullClippingRectangle();
+    virtual bool updateCustom(gsl::not_null<CustomRenderComponent*> customRenderer);
+    virtual void renderCustom(gsl::not_null<CustomRenderComponent*> customRenderer, int pass, RectangleArea& renderAABB);
+    virtual void cleanup();
+    virtual void removePersistentMeshes();
+    virtual mce::TexturePtr getTexture(const ResourceLocation& resourceLocation, bool forceReload);
+    virtual mce::TexturePtr getZippedTexture(const Core::Path& zippedFolderPath, const ResourceLocation& resourceLocation, bool forceReload);
+    virtual void unloadTexture(ResourceLocation const &);
+};

src/api/mc/world/Minecraft.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <api/mc/world/Timer.hpp>
+
+class Minecraft {
+public:
+    std::byte _pad0[216];
+    Timer& mSimTimer;
+    Timer& mRealTimer;
+public:
+    Minecraft* $ctor(
+        void* app,
+        void* gameCallbacks,
+        void* allowList,
+        void* permissionsFile,
+        void* filePathManager,
+        void* maxPlayerIdleTime,
+        void* eventing,
+        void* network,
+        void* packetSender,
+        void* clientSubId,
+        void* simTimer,
+        void* realTimer,
+        void* contentTierManager,
+        void* serverMetrics
+    );
+};

src/api/mc/world/Timer.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+class Timer {
+public:
+    float mTicksPerSecond;
+};