Merge 8935c520c0 into f1b8f495b6

src/app/CMakeLists.txt

@@ -32,6 +32,8 @@ if(WHOA_SYSTEM_MAC)
             "-framework AppKit"
             "-framework Carbon"
             "-framework IOKit"
+            "-framework Metal"
+            "-framework QuartzCore"
     )
 
     install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mac/MainMenu.nib DESTINATION "bin")

src/app/mac/EngineMTLLayerView.h

@@ -0,0 +1,9 @@
+#ifndef APP_MAC_ENGINE_MTL_LAYER_VIEW_H
+#define APP_MAC_ENGINE_MTL_LAYER_VIEW_H
+
+#include "app/mac/EngineGLLayerView.h"
+
+@interface EngineMTLLayerView : EngineGLLayerView
+@end
+
+#endif

src/app/mac/EngineMTLLayerView.mm

@@ -0,0 +1,36 @@
+#include "app/mac/EngineMTLLayerView.h"
+#import <QuartzCore/CAMetalLayer.h>
+
+@implementation EngineMTLLayerView
+
+- (CALayer*)makeBackingLayer {
+    return [CAMetalLayer layer];
+}
+
+- (id)initWithFrame:(NSRect)frame glWindow:(GLWindow*)window {
+    self = [super initWithFrame:frame glWindow:window];
+
+    if (self) {
+        [self setWantsLayer:YES];
+    }
+
+    return self;
+}
+
+- (void)drawRect:(NSRect)dirtyRect {
+    // Rendering is driven by CGxDeviceMTL.
+}
+
+- (void)update {
+    [super update];
+
+    if (![self.layer isKindOfClass:[CAMetalLayer class]]) {
+        return;
+    }
+
+    CAMetalLayer* layer = (CAMetalLayer*)self.layer;
+    CGSize size = [self convertSizeToBacking:self.bounds.size];
+    layer.drawableSize = size;
+}
+
+@end

src/app/mac/View.mm

@@ -1,7 +1,9 @@
 #include "app/mac/View.h"
 #include "app/mac/EngineGLLayerView.h"
+#include "app/mac/EngineMTLLayerView.h"
 #include "app/mac/WindowCallbacks.h"
 #include "gx/gll/GLWindow.h"
+#include "gx/Device.hpp"
 
 GLWindowCallbacks EngineViewCallbacks = {
     &MacOnResized,
@@ -23,5 +25,9 @@ void AssignEngineViewCallbacks(GLWindowCallbacks* callbacks) {
 }
 
 Class GetEngineViewClass() {
+    if (GxDevApi() == GxApi_Metal) {
+        return [EngineMTLLayerView class];
+    }
+
     return [EngineGLLayerView class];
 }

src/app/mac/WindowCallbacks.mm

@@ -2,6 +2,7 @@
 #include "app/mac/MacClient.h"
 #include "event/Input.hpp"
 #include "gx/gll/CGxDeviceGLL.hpp"
+#include "gx/mtl/CGxDeviceMTL.hpp"
 #include "gx/Device.hpp"
 #include "gx/Window.hpp"
 #include <bc/Debug.hpp>
@@ -171,7 +172,11 @@ void MacOnResized(int32_t width, int32_t height, bool a3) {
         return;
     }
 
-    static_cast<CGxDeviceGLL*>(g_theGxDevicePtr)->Resize(width, height);
+    if (GxDevApi() == GxApi_GLL) {
+        static_cast<CGxDeviceGLL*>(g_theGxDevicePtr)->Resize(width, height);
+    } else if (GxDevApi() == GxApi_Metal) {
+        static_cast<CGxDeviceMTL*>(g_theGxDevicePtr)->Resize(width, height);
+    }
 
     OsQueuePut(OS_INPUT_SIZE, width, height, 0, 0);
 

src/client/Client.cpp

@@ -18,6 +18,7 @@
 #include "sound/Interface.hpp"
 #include "ui/FrameScript.hpp"
 #include "ui/FrameXML.hpp"
+#include "ui/Game.hpp"
 #include "util/Random.hpp"
 #include "world/World.hpp"
 #include <bc/Debug.hpp>
@@ -85,6 +86,10 @@ void ClientInitializeGame(uint32_t mapId, C3Vector position) {
 
     // TODO
 
+    CGGameUI::InitializeGame();
+
+    // TODO
+
     EventRegister(EVENT_ID_IDLE, ClientIdle);
 
     // TODO

src/console/Device.cpp

@@ -6,6 +6,7 @@
 #include "gx/Adapter.hpp"
 #include "gx/Device.hpp"
 #include <storm/Array.hpp>
+#include <cstdlib>
 #include <cstring>
 
 static CGxDevice* s_device;
@@ -417,6 +418,13 @@ void ConsoleDeviceInitialize(const char* title) {
     api = GxApi_GLL;
 #endif
 
+#if defined(WHOA_SYSTEM_MAC)
+    const char* apiOverride = getenv("WHOA_GX_API");
+    if (apiOverride && !strcmp(apiOverride, "metal")) {
+        api = GxApi_Metal;
+    }
+#endif
+
     s_device = GxDevCreate(api, OsWindowProc, format);
 
     // TODO

src/glue/CGlueMgr.cpp

@@ -25,6 +25,7 @@
 #include "ui/FrameScript.hpp"
 #include "ui/FrameXML.hpp"
 #include "ui/Interface.hpp"
+#include "ui/Key.hpp"
 #include "ui/ScriptFunctions.hpp"
 #include "ui/game/CGVideoOptions.hpp"
 #include "ui/simple/CSimpleModelFFX.hpp"
@@ -36,25 +37,6 @@
 #include <common/MD5.hpp>
 #include <cstdio>
 
-unsigned char InterfaceKey[256] = {
-    0xC3, 0x5B, 0x50, 0x84, 0xB9, 0x3E, 0x32, 0x42, 0x8C, 0xD0, 0xC7, 0x48, 0xFA, 0x0E, 0x5D, 0x54,
-    0x5A, 0xA3, 0x0E, 0x14, 0xBA, 0x9E, 0x0D, 0xB9, 0x5D, 0x8B, 0xEE, 0xB6, 0x84, 0x93, 0x45, 0x75,
-    0xFF, 0x31, 0xFE, 0x2F, 0x64, 0x3F, 0x3D, 0x6D, 0x07, 0xD9, 0x44, 0x9B, 0x40, 0x85, 0x59, 0x34,
-    0x4E, 0x10, 0xE1, 0xE7, 0x43, 0x69, 0xEF, 0x7C, 0x16, 0xFC, 0xB4, 0xED, 0x1B, 0x95, 0x28, 0xA8,
-    0x23, 0x76, 0x51, 0x31, 0x57, 0x30, 0x2B, 0x79, 0x08, 0x50, 0x10, 0x1C, 0x4A, 0x1A, 0x2C, 0xC8,
-    0x8B, 0x8F, 0x05, 0x2D, 0x22, 0x3D, 0xDB, 0x5A, 0x24, 0x7A, 0x0F, 0x13, 0x50, 0x37, 0x8F, 0x5A,
-    0xCC, 0x9E, 0x04, 0x44, 0x0E, 0x87, 0x01, 0xD4, 0xA3, 0x15, 0x94, 0x16, 0x34, 0xC6, 0xC2, 0xC3,
-    0xFB, 0x49, 0xFE, 0xE1, 0xF9, 0xDA, 0x8C, 0x50, 0x3C, 0xBE, 0x2C, 0xBB, 0x57, 0xED, 0x46, 0xB9,
-    0xAD, 0x8B, 0xC6, 0xDF, 0x0E, 0xD6, 0x0F, 0xBE, 0x80, 0xB3, 0x8B, 0x1E, 0x77, 0xCF, 0xAD, 0x22,
-    0xCF, 0xB7, 0x4B, 0xCF, 0xFB, 0xF0, 0x6B, 0x11, 0x45, 0x2D, 0x7A, 0x81, 0x18, 0xF2, 0x92, 0x7E,
-    0x98, 0x56, 0x5D, 0x5E, 0x69, 0x72, 0x0A, 0x0D, 0x03, 0x0A, 0x85, 0xA2, 0x85, 0x9C, 0xCB, 0xFB,
-    0x56, 0x6E, 0x8F, 0x44, 0xBB, 0x8F, 0x02, 0x22, 0x68, 0x63, 0x97, 0xBC, 0x85, 0xBA, 0xA8, 0xF7,
-    0xB5, 0x40, 0x68, 0x3C, 0x77, 0x86, 0x6F, 0x4B, 0xD7, 0x88, 0xCA, 0x8A, 0xD7, 0xCE, 0x36, 0xF0,
-    0x45, 0x6E, 0xD5, 0x64, 0x79, 0x0F, 0x17, 0xFC, 0x64, 0xDD, 0x10, 0x6F, 0xF3, 0xF5, 0xE0, 0xA6,
-    0xC3, 0xFB, 0x1B, 0x8C, 0x29, 0xEF, 0x8E, 0xE5, 0x34, 0xCB, 0xD1, 0x2A, 0xCE, 0x79, 0xC3, 0x9A,
-    0x0D, 0x36, 0xEA, 0x01, 0xE0, 0xAA, 0x91, 0x20, 0x54, 0xF0, 0x72, 0xD8, 0x1E, 0xC7, 0x89, 0xD2
-};
-
 int32_t CGlueMgr::m_acceptedEULA = 1; // TODO
 int32_t CGlueMgr::m_acceptedTerminationWithoutNotice;
 int32_t CGlueMgr::m_acceptedTOS = 1; // TODO
@@ -1005,51 +987,53 @@ void CGlueMgr::Resume() {
 
     DeleteInterfaceFiles();
 
-    MD5_CTX md5;
-    unsigned char digest1[16];
-    unsigned char digest2[16];
+    uint8_t digest1[16];
 
-    int32_t v8;
-    unsigned char* v9;
-    unsigned char* v10;
-
-    MD5Init(&md5);
-
-    switch (FrameXML_CheckSignature("Interface\\GlueXML\\GlueXML.toc", 0, InterfaceKey, digest1)) {
-        case 0:
+    switch (FrameXML_CheckSignature("Interface\\GlueXML\\GlueXML.toc", nullptr, InterfaceKey, digest1)) {
+        case 0: {
             status.Add(STATUS_WARNING, "GlueXML missing signature");
             ClientPostClose(9);
-            return;
 
-        case 1:
+            return;
+        }
+
+        case 1: {
             status.Add(STATUS_WARNING, "GlueXML has corrupt signature");
             ClientPostClose(9);
-            return;
 
-        case 2:
+            return;
+        }
+
+        case 2: {
             status.Add(STATUS_WARNING, "GlueXML is modified or corrupt");
             ClientPostClose(9);
+
             return;
+        }
 
-        case 3:
-            FrameXML_FreeHashNodes();
-            FrameXML_CreateFrames("Interface\\GlueXML\\GlueXML.toc", 0, &md5, &status);
-
-            MD5Final(digest2, &md5);
-
-            v8 = 16;
-            v9 = digest2;
-            v10 = digest1;
-
+        case 3: {
+            // Success
             break;
+        }
 
-        default:
+        default: {
             ClientPostClose(9);
+
             return;
+        }
     }
 
-    // TODO
-    // - some kind of digest validation?
+    MD5_CTX md5;
+    MD5Init(&md5);
+
+    FrameXML_FreeHashNodes();
+
+    FrameXML_CreateFrames("Interface\\GlueXML\\GlueXML.toc", nullptr, &md5, &status);
+
+    uint8_t digest2[16];
+    MD5Final(digest2, &md5);
+
+    // TODO digest validation
 
     FrameScript_SignalEvent(22, nullptr);
 

src/gx/CGxDevice.cpp

@@ -18,6 +18,7 @@
 
 #if defined(WHOA_SYSTEM_MAC)
     #include "gx/gll/CGxDeviceGLL.hpp"
+    #include "gx/mtl/CGxDeviceMTL.hpp"
     #include "gx/mac/Display.hpp"
     #include <ApplicationServices/ApplicationServices.h>
     #include <OpenGL/OpenGL.h>
@@ -117,6 +118,8 @@ int32_t CGxDevice::AdapterFormats(EGxApi api, TSGrowableArray<CGxFormat>& adapte
         CGxDevice::OpenGlAdapterFormats(adapterFormats);
     } else if (api == GxApi_GLL) {
         CGxDevice::GLLAdapterFormats(adapterFormats);
+    } else if (api == GxApi_Metal) {
+        CGxDevice::OpenGlAdapterFormats(adapterFormats);
     }
 
 #elif defined(WHOA_SYSTEM_LINUX)
@@ -228,6 +231,11 @@ CGxDevice* CGxDevice::NewGLL() {
     auto m = SMemAlloc(sizeof(CGxDeviceGLL), __FILE__, __LINE__, 0x0);
     return new (m) CGxDeviceGLL();
 }
+
+CGxDevice* CGxDevice::NewMTL() {
+    auto m = SMemAlloc(sizeof(CGxDeviceMTL), __FILE__, __LINE__, 0x0);
+    return new (m) CGxDeviceMTL();
+}
 #endif
 
 CGxDevice* CGxDevice::NewOpenGl() {

src/gx/CGxDevice.hpp

@@ -70,6 +70,7 @@ class CGxDevice {
 #endif
 #if defined(WHOA_SYSTEM_MAC)
         static CGxDevice* NewGLL();
+        static CGxDevice* NewMTL();
 #endif
         static CGxDevice* NewOpenGl();
         static void OpenGlAdapterFormats(TSGrowableArray<CGxFormat>& adapterFormats);

src/gx/CMakeLists.txt

@@ -20,6 +20,7 @@ if(WHOA_SYSTEM_MAC)
     file(GLOB MAC_SOURCES
         "gll/*.cpp"
         "gll/*.mm"
+        "mtl/*.mm"
         "mac/*.cpp"
     )
 

src/gx/Device.cpp

@@ -24,6 +24,8 @@ CGxDevice* GxDevCreate(EGxApi api, int32_t (*windowProc)(void* window, uint32_t
             device = CGxDevice::NewOpenGl();
         } else if (api == GxApi_GLL) {
             device = CGxDevice::NewGLL();
+        } else if (api == GxApi_Metal) {
+            device = CGxDevice::NewMTL();
         } else {
             // Error
         }

src/gx/Types.hpp

@@ -35,7 +35,8 @@ enum EGxApi {
     GxApi_D3d10 = 3,
     GxApi_D3d11 = 4,
     GxApi_GLL = 5,
-    GxApis_Last = 6
+    GxApi_Metal = 6,
+    GxApis_Last = 7
 };
 
 enum EGxBlend {

src/gx/mtl/CGxDeviceMTL.hpp

@@ -0,0 +1,81 @@
+#ifndef GX_MTL_C_GX_DEVICE_MTL_HPP
+#define GX_MTL_C_GX_DEVICE_MTL_HPP
+
+#include "gx/CGxDevice.hpp"
+#include "gx/gll/GLWindow.h"
+
+class CGxBatch;
+class CGxShader;
+
+class CGxDeviceMTL : public CGxDevice {
+    public:
+        // Member variables
+        GLWindow m_window;
+
+        // Virtual member functions
+        void ITexMarkAsUpdated(CGxTex*) override;
+        void IRsSendToHw(EGxRenderState) override;
+        int32_t DeviceCreate(int32_t (*windowProc)(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam), const CGxFormat&) override;
+        int32_t DeviceSetFormat(const CGxFormat&) override;
+        void* DeviceWindow() override;
+        void DeviceWM(EGxWM wm, uintptr_t param1, uintptr_t param2) override {};
+        void CapsWindowSize(CRect&) override;
+        void CapsWindowSizeInScreenCoords(CRect& dst) override;
+        void ScenePresent() override;
+        void SceneClear(uint32_t, CImVector) override;
+        void Draw(CGxBatch* batch, int32_t indexed) override;
+        void PoolSizeSet(CGxPool*, uint32_t) override;
+        char* BufLock(CGxBuf*) override;
+        int32_t BufUnlock(CGxBuf*, uint32_t) override;
+        void BufData(CGxBuf* buf, const void* data, size_t size, uintptr_t offset) override;
+        void TexDestroy(CGxTex* texId) override;
+        void IShaderCreate(CGxShader*) override;
+        void ShaderCreate(CGxShader*[], EGxShTarget, const char*, const char*, int32_t) override;
+        int32_t StereoEnabled(void) override;
+        void XformSetProjection(const C44Matrix& matrix) override;
+
+        // Member functions
+        CGxDeviceMTL();
+        void Resize(uint32_t width, uint32_t height);
+
+    private:
+        void ISetCaps(const CGxFormat& format);
+        void EnsureLibrary();
+        void BeginFrame();
+        void* GetPipeline(EGxVertexBufferFormat format, bool useColor, bool useSkin, bool useTex, int32_t blendMode);
+        void* GetPoolBuffer(CGxPool* pool);
+        void ITexCreate(CGxTex* texId);
+        void ITexUpload(CGxTex* texId);
+        void* GetTexture(CGxTex* texId);
+        void* GetSampler(CGxTex* texId);
+        void EnsureFallbackTexture();
+        void EnsureDepthTexture(uint32_t width, uint32_t height);
+        void* GetDepthState(bool depthTest, bool depthWrite, uint32_t depthFunc);
+        void* m_device = nullptr;
+        void* m_commandQueue = nullptr;
+        void* m_layer = nullptr;
+        void* m_shaderLibrary = nullptr;
+        void* m_pipelineColor[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSolid[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSkin[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineColorTex[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSolidTex[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSkinTex[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineColorTex2[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSolidTex2[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_pipelineSkinTex2[GxVertexBufferFormats_Last][GxBlends_Last] = {};
+        void* m_frameCommandBuffer = nullptr;
+        void* m_frameEncoder = nullptr;
+        void* m_frameDrawable = nullptr;
+        uint32_t m_frameHasDraw = 0;
+        uint32_t m_clearMask = 0;
+        uint32_t m_clearColor = 0;
+        void* m_fallbackTexture = nullptr;
+        void* m_fallbackSampler = nullptr;
+        void* m_depthTexture = nullptr;
+        uint32_t m_depthWidth = 0;
+        uint32_t m_depthHeight = 0;
+        void* m_depthStates[2][2][4] = {};
+};
+
+#endif

src/ui/FrameScript_Object.cpp

@@ -5,6 +5,12 @@
 
 int32_t FrameScript_Object::s_objectTypes = 0;
 
+FrameScript_Object::ScriptIx::~ScriptIx() {
+    if (this->luaRef) {
+        luaL_unref(FrameScript_GetContext(), LUA_REGISTRYINDEX, this->luaRef);
+    }
+}
+
 int32_t FrameScript_Object::CreateScriptMetaTable(lua_State* L, void (*a2)(lua_State* L)) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, "__index");
@@ -24,12 +30,6 @@ void FrameScript_Object::FillScriptMethodTable(lua_State *L, FrameScript_Method
     }
 }
 
-FrameScript_Object::~FrameScript_Object() {
-    if (this->m_onEvent.luaRef) {
-        luaL_unref(FrameScript_GetContext(), LUA_REGISTRYINDEX, this->m_onEvent.luaRef);
-    }
-}
-
 const char* FrameScript_Object::GetDisplayName() {
     const char* name = this->GetName();
     return name ? name : "<unnamed>";

src/ui/FrameScript_Object.hpp

@@ -14,6 +14,7 @@ class FrameScript_Object {
         struct ScriptIx {
             int32_t luaRef = 0;
             const char* unk = nullptr;
+            ~ScriptIx();
         };
 
         class ScriptFunction {
@@ -34,7 +35,7 @@ class FrameScript_Object {
         ScriptIx m_onEvent;
 
         // Virtual member functions
-        virtual ~FrameScript_Object();
+        virtual ~FrameScript_Object() = default;
         virtual char* GetName() = 0;
         virtual int32_t GetScriptMetaTable() = 0;
         virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);

src/ui/Game.hpp

@@ -0,0 +1,6 @@
+#ifndef UI_GAME_HPP
+#define UI_GAME_HPP
+
+#include "ui/game/CGGameUI.hpp"
+
+#endif

src/ui/Key.cpp

@@ -0,0 +1,20 @@
+#include "ui/Key.hpp"
+
+uint8_t InterfaceKey[256] = {
+    0xC3, 0x5B, 0x50, 0x84, 0xB9, 0x3E, 0x32, 0x42, 0x8C, 0xD0, 0xC7, 0x48, 0xFA, 0x0E, 0x5D, 0x54,
+    0x5A, 0xA3, 0x0E, 0x14, 0xBA, 0x9E, 0x0D, 0xB9, 0x5D, 0x8B, 0xEE, 0xB6, 0x84, 0x93, 0x45, 0x75,
+    0xFF, 0x31, 0xFE, 0x2F, 0x64, 0x3F, 0x3D, 0x6D, 0x07, 0xD9, 0x44, 0x9B, 0x40, 0x85, 0x59, 0x34,
+    0x4E, 0x10, 0xE1, 0xE7, 0x43, 0x69, 0xEF, 0x7C, 0x16, 0xFC, 0xB4, 0xED, 0x1B, 0x95, 0x28, 0xA8,
+    0x23, 0x76, 0x51, 0x31, 0x57, 0x30, 0x2B, 0x79, 0x08, 0x50, 0x10, 0x1C, 0x4A, 0x1A, 0x2C, 0xC8,
+    0x8B, 0x8F, 0x05, 0x2D, 0x22, 0x3D, 0xDB, 0x5A, 0x24, 0x7A, 0x0F, 0x13, 0x50, 0x37, 0x8F, 0x5A,
+    0xCC, 0x9E, 0x04, 0x44, 0x0E, 0x87, 0x01, 0xD4, 0xA3, 0x15, 0x94, 0x16, 0x34, 0xC6, 0xC2, 0xC3,
+    0xFB, 0x49, 0xFE, 0xE1, 0xF9, 0xDA, 0x8C, 0x50, 0x3C, 0xBE, 0x2C, 0xBB, 0x57, 0xED, 0x46, 0xB9,
+    0xAD, 0x8B, 0xC6, 0xDF, 0x0E, 0xD6, 0x0F, 0xBE, 0x80, 0xB3, 0x8B, 0x1E, 0x77, 0xCF, 0xAD, 0x22,
+    0xCF, 0xB7, 0x4B, 0xCF, 0xFB, 0xF0, 0x6B, 0x11, 0x45, 0x2D, 0x7A, 0x81, 0x18, 0xF2, 0x92, 0x7E,
+    0x98, 0x56, 0x5D, 0x5E, 0x69, 0x72, 0x0A, 0x0D, 0x03, 0x0A, 0x85, 0xA2, 0x85, 0x9C, 0xCB, 0xFB,
+    0x56, 0x6E, 0x8F, 0x44, 0xBB, 0x8F, 0x02, 0x22, 0x68, 0x63, 0x97, 0xBC, 0x85, 0xBA, 0xA8, 0xF7,
+    0xB5, 0x40, 0x68, 0x3C, 0x77, 0x86, 0x6F, 0x4B, 0xD7, 0x88, 0xCA, 0x8A, 0xD7, 0xCE, 0x36, 0xF0,
+    0x45, 0x6E, 0xD5, 0x64, 0x79, 0x0F, 0x17, 0xFC, 0x64, 0xDD, 0x10, 0x6F, 0xF3, 0xF5, 0xE0, 0xA6,
+    0xC3, 0xFB, 0x1B, 0x8C, 0x29, 0xEF, 0x8E, 0xE5, 0x34, 0xCB, 0xD1, 0x2A, 0xCE, 0x79, 0xC3, 0x9A,
+    0x0D, 0x36, 0xEA, 0x01, 0xE0, 0xAA, 0x91, 0x20, 0x54, 0xF0, 0x72, 0xD8, 0x1E, 0xC7, 0x89, 0xD2
+};

src/ui/Key.hpp

@@ -0,0 +1,8 @@
+#ifndef UI_KEY_HPP
+#define UI_KEY_HPP
+
+#include <cstdint>
+
+extern uint8_t InterfaceKey[256];
+
+#endif

src/ui/game/CGGameUI.cpp

@@ -0,0 +1,94 @@
+#include "ui/game/CGGameUI.hpp"
+#include "client/Client.hpp"
+#include "ui/FrameXML.hpp"
+#include "ui/Key.hpp"
+#include "ui/game/CGWorldFrame.hpp"
+#include "ui/simple/CSimpleTop.hpp"
+#include "util/CStatus.hpp"
+#include <common/MD5.hpp>
+
+CSimpleTop* CGGameUI::s_simpleTop;
+
+void CGGameUI::Initialize() {
+    // TODO
+
+    CGGameUI::s_simpleTop = STORM_NEW(CSimpleTop);
+
+    // TODO
+
+    CGGameUI::RegisterFrameFactories();
+
+    // TODO
+
+    CStatus status;
+
+    // TODO
+
+    uint8_t digest1[16];
+
+    switch (FrameXML_CheckSignature("Interface\\FrameXML\\FrameXML.toc", "Interface\\FrameXML\\Bindings.xml", InterfaceKey, digest1)) {
+        case 0: {
+            status.Add(STATUS_WARNING, "FrameXML missing signature");
+            ClientPostClose(10);
+
+            break;
+        }
+
+        case 1: {
+            status.Add(STATUS_WARNING, "FrameXML has corrupt signature");
+            ClientPostClose(10);
+
+            break;
+        }
+
+        case 2: {
+            status.Add(STATUS_WARNING, "FrameXML is modified or corrupt");
+            ClientPostClose(10);
+
+            break;
+        }
+
+        case 3: {
+            // Success
+            break;
+        }
+
+        default: {
+            ClientPostClose(10);
+
+            break;
+        }
+    }
+
+    MD5_CTX md5;
+    MD5Init(&md5);
+
+    // TODO file count and progress bar logic
+
+    FrameXML_FreeHashNodes();
+
+    FrameXML_CreateFrames("Interface\\FrameXML\\FrameXML.toc", nullptr, &md5, &status);
+
+    // TODO CGUIBindings::s_bindings->Load("Interface\\FrameXML\\Bindings.xml", &md5, &status);
+
+    uint8_t digest2[16];
+    MD5Final(digest2, &md5);
+
+    // TODO digest validation
+
+    // TODO
+}
+
+void CGGameUI::InitializeGame() {
+    // TODO
+
+    CGGameUI::Initialize();
+
+    // TODO
+}
+
+void CGGameUI::RegisterFrameFactories() {
+    FrameXML_RegisterFactory("WorldFrame", &CGWorldFrame::Create, true);
+
+    // TODO register remaining factories
+}

src/ui/game/CGGameUI.hpp

@@ -0,0 +1,17 @@
+#ifndef UI_GAME_C_G_GAME_UI_HPP
+#define UI_GAME_C_G_GAME_UI_HPP
+
+class CSimpleTop;
+
+class CGGameUI {
+    public:
+        // Static variables
+        static CSimpleTop* s_simpleTop;
+
+        // Static functions
+        static void Initialize();
+        static void InitializeGame();
+        static void RegisterFrameFactories();
+};
+
+#endif

src/ui/game/CGWorldFrame.cpp

@@ -0,0 +1,22 @@
+#include "ui/game/CGWorldFrame.hpp"
+#include <storm/Memory.hpp>
+
+CSimpleFrame* CGWorldFrame::Create(CSimpleFrame* parent) {
+    // TODO use CDataAllocator
+
+    return STORM_NEW(CGWorldFrame)(parent);
+}
+
+CGWorldFrame::CGWorldFrame(CSimpleFrame* parent) : CSimpleFrame(parent) {
+    // TODO
+
+    CGWorldFrame::s_currentWorldFrame = this;
+
+    // TODO
+
+    this->EnableEvent(SIMPLE_EVENT_KEY, -1);
+    this->EnableEvent(SIMPLE_EVENT_MOUSE, -1);
+    this->EnableEvent(SIMPLE_EVENT_MOUSEWHEEL, -1);
+
+    // TODO
+}

src/ui/game/CGWorldFrame.hpp

@@ -0,0 +1,19 @@
+#ifndef UI_GAME_C_G_WORLD_FRAME_HPP
+#define UI_GAME_C_G_WORLD_FRAME_HPP
+
+#include "ui/simple/CSimpleFrame.hpp"
+#include <cstdint>
+
+class CGWorldFrame : public CSimpleFrame {
+    public:
+        // Static variables
+        CGWorldFrame* s_currentWorldFrame;
+
+        // Static functions
+        static CSimpleFrame* Create(CSimpleFrame* parent);
+
+        // Member functions
+        CGWorldFrame(CSimpleFrame* parent);
+};
+
+#endif

src/ui/simple/CSimpleFrame.cpp

@@ -64,11 +64,27 @@ CSimpleFrame::CSimpleFrame(CSimpleFrame* parent) : CScriptRegion() {
 }
 
 CSimpleFrame::~CSimpleFrame() {
-    // TODO
-
     this->m_intAC = 3;
 
     this->m_top->UnregisterFrame(this);
+    this->m_top = nullptr;
+
+    if (this->m_titleRegion) {
+        delete this->m_titleRegion;
+    }
+
+    for (int32_t layer = 0; layer < NUM_SIMPLEFRAME_DRAWLAYERS; layer++) {
+        this->m_drawlayers[layer].UnlinkAll();
+
+        if (this->m_batch[layer]) {
+            delete this->m_batch[layer];
+        }
+    }
+
+    while (auto region = this->m_regions.Head()) {
+        this->m_regions.UnlinkNode(region);
+        delete region;
+    }
 
     // TODO
 }

src/ui/simple/CSimpleTop.cpp

@@ -400,6 +400,18 @@ CSimpleTop::CSimpleTop() : CLayoutFrame() {
 CSimpleTop::~CSimpleTop() {
     // TODO
 
+    while (auto frame = this->m_frames.Head()) {
+        this->m_frames.UnlinkNode(frame);
+        delete frame;
+    }
+
+    for (auto& strata : this->m_strata) {
+        delete strata;
+        strata = nullptr;
+    }
+
+    // TODO
+
     this->DisableEvents();
 
     HandleClose(this->m_screenLayer);

src/world/CWorld.cpp

@@ -17,6 +17,35 @@ uint32_t CWorld::s_tickTimeMs;
 float CWorld::s_tickTimeSec;
 Weather* CWorld::s_weather;
 
+HWORLDOBJECT CWorld::AddObject(CM2Model* model, void* handler, void* handlerParam, uint64_t param64, uint32_t param32, uint32_t objFlags) {
+    auto entity = CMap::AllocEntity(objFlags & 0x8 ? true : false);
+
+    entity->m_model = model;
+    entity->m_param64 = param64;
+    entity->m_param32 = param32;
+
+    // TODO
+
+    entity->m_dirLightScale = 1.0f;
+    entity->m_dirLightScaleTarget = 1.0f;
+
+    // TODO
+
+    entity->m_type |= CMapBaseObj::Type_200;
+
+    // TODO
+
+    entity->m_flags = 0x0;
+
+    if (objFlags & 0x20) {
+        entity->m_flags = 0x20000;
+    }
+
+    // TODO
+
+    return reinterpret_cast<HWORLDOBJECT>(entity);
+}
+
 uint32_t CWorld::GetCurTimeMs() {
     return CWorld::s_curTimeMs;
 }

src/world/CWorld.hpp

@@ -2,9 +2,11 @@
 #define WORLD_C_WORLD_HPP
 
 #include "event/Event.hpp"
+#include "world/Types.hpp"
 #include <tempest/Vector.hpp>
 #include <cstdint>
 
+class CM2Model;
 class Weather;
 
 class CWorld {
@@ -51,6 +53,7 @@ class CWorld {
         static Weather* s_weather;
 
         // Public static functions
+        static HWORLDOBJECT AddObject(CM2Model* model, void* handler, void* handlerParam, uint64_t param64, uint32_t param32, uint32_t objFlags);
         static uint32_t GetCurTimeMs();
         static float GetCurTimeSec();
         static uint32_t GetGameTimeFixed();

src/world/map/CMap.cpp

@@ -39,6 +39,7 @@ CMapEntity* CMap::AllocEntity(int32_t a1) {
 
     if (ObjectAlloc(*CMap::s_entityHeap, &memHandle, &mem, false)) {
         entity = new (mem) CMapEntity();
+        entity->m_memHandle = memHandle;
     } else {
         entity = nullptr;
     }

src/world/map/CMap.hpp

@@ -2,11 +2,10 @@
 #define WORLD_MAP_C_MAP_HPP
 
 #include "world/map/CMapBaseObj.hpp"
+#include "world/map/CMapEntity.hpp"
 #include <storm/List.hpp>
 #include <cstdint>
 
-class CMapEntity;
-
 class CMap {
     public:
         // Static variables

src/world/map/CMapBaseObj.hpp

@@ -18,6 +18,9 @@ class CMapBaseObjLink {
 };
 
 class CMapBaseObj {
+    friend class CMap;
+    friend class CWorld;
+
     public:
         // Enums
         enum {
@@ -29,10 +32,13 @@ class CMapBaseObj {
             Type_Entity         = 0x20,
             Type_DoodadDef      = 0x40,
             Type_Light          = 0x80,
+            Type_100            = 0x100,
+            Type_200            = 0x200,
         };
 
         // Public member variables
         uint32_t m_memHandle;
+        uint32_t m_flags = 0x0;
         TSLink<CMapBaseObj> m_lameAssLink;
         STORM_EXPLICIT_LIST(CMapBaseObjLink, ownerLink) m_parentLinkList;
 

src/world/map/CMapEntity.cpp

@@ -0,0 +1,5 @@
+#include "world/map/CMapEntity.hpp"
+
+CMapEntity::CMapEntity() {
+    this->m_type |= CMapBaseObj::Type_Entity;
+}

src/world/map/CMapEntity.hpp

@@ -2,10 +2,22 @@
 #define WORLD_MAP_C_MAP_ENTITY_HPP
 
 #include "world/map/CMapStaticEntity.hpp"
+#include <tempest/Vector.hpp>
 
 class CMapEntity : public CMapStaticEntity {
     public:
+        // Member variables
+        void* m_handler = nullptr;
+        void* m_handlerParam = nullptr;
+        uint64_t m_param64 = 0;
+        uint32_t m_param32 = 0;
         // TODO
+        CImVector m_ambientTarget = { 0xFF, 0x00, 0x00, 0x00 };
+        float m_dirLightScaleTarget = 0.0f;
+        // TODO
+
+        // Member functions
+        CMapEntity();
 };
 
 #endif

src/world/map/CMapStaticEntity.hpp

@@ -2,10 +2,19 @@
 #define WORLD_MAP_C_MAP_STATIC_ENTITY_HPP
 
 #include "world/map/CMapBaseObj.hpp"
+#include <tempest/Vector.hpp>
+
+class CM2Model;
 
 class CMapStaticEntity : public CMapBaseObj {
     public:
+        // Member variables
         // TODO
+        CM2Model* m_model = nullptr;
+        // TODO
+        CImVector m_ambient = {};
+        CImVector m_interiorDirColor = {};
+        float m_dirLightScale = 0.0f;
 };
 
 #endif

test/CMakeLists.txt

@@ -22,6 +22,8 @@ if(WHOA_SYSTEM_MAC)
             "-framework AppKit"
             "-framework Carbon"
             "-framework IOKit"
+            "-framework Metal"
+            "-framework QuartzCore"
     )
 endif()