Merge branch 'master' of https://github.com/yuzu-emu/yuzu

appveyor.yml

@@ -53,7 +53,7 @@ build_script:
           # https://www.appveyor.com/docs/build-phase
           msbuild msvc_build/yuzu.sln /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
         } else {
-          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -C mingw_build/ 2>&1'
+          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -j4 -C mingw_build/ 2>&1'
         }
 
 after_build:

src/core/hle/service/am/am.cpp

@@ -155,7 +155,7 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
     RegisterHandlers(functions);
 
     launchable_event =
-        Kernel::Event::Create(Kernel::ResetType::OneShot, "ISelfController:LaunchableEvent");
+        Kernel::Event::Create(Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
 }
 
 void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
@@ -436,13 +436,13 @@ public:
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
             {1, nullptr, "IsCompleted"},
-            {10, nullptr, "Start"},
+            {10, &ILibraryAppletAccessor::Start, "Start"},
             {20, nullptr, "RequestExit"},
             {25, nullptr, "Terminate"},
-            {30, nullptr, "GetResult"},
+            {30, &ILibraryAppletAccessor::GetResult, "GetResult"},
             {50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
             {100, &ILibraryAppletAccessor::PushInData, "PushInData"},
-            {101, nullptr, "PopOutData"},
+            {101, &ILibraryAppletAccessor::PopOutData, "PopOutData"},
             {102, nullptr, "PushExtraStorage"},
             {103, nullptr, "PushInteractiveInData"},
             {104, nullptr, "PopInteractiveOutData"},
@@ -470,6 +470,20 @@ private:
         NGLOG_WARNING(Service_AM, "(STUBBED) called");
     }
 
+    void GetResult(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    }
+
+    void Start(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    }
+
     void PushInData(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         storage_stack.push(rp.PopIpcInterface<AM::IStorage>());
@@ -480,6 +494,16 @@ private:
         NGLOG_DEBUG(Service_AM, "called");
     }
 
+    void PopOutData(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<AM::IStorage>(std::move(storage_stack.top()));
+
+        storage_stack.pop();
+
+        NGLOG_DEBUG(Service_AM, "called");
+    }
+
     std::stack<std::shared_ptr<AM::IStorage>> storage_stack;
     Kernel::SharedPtr<Kernel::Event> state_changed_event;
 };

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -26,11 +26,19 @@ public:
 private:
     enum class IoctlCommand : u32_le {
         IocSetNVMAPfdCommand = 0x40044801,
+        IocAllocGPFIFOCommand = 0x40084805,
         IocSetClientDataCommand = 0x40084714,
         IocGetClientDataCommand = 0x80084715,
         IocZCullBind = 0xc010480b,
         IocSetErrorNotifierCommand = 0xC018480C,
         IocChannelSetPriorityCommand = 0x4004480D,
+        IocEnableCommand = 0x0000480E,
+        IocDisableCommand = 0x0000480F,
+        IocPreemptCommand = 0x00004810,
+        IocForceResetCommand = 0x00004811,
+        IocEventIdControlCommand = 0x40084812,
+        IocGetErrorNotificationCommand = 0xC0104817,
+        IocAllocGPFIFOExCommand = 0x40204818,
         IocAllocGPFIFOEx2Command = 0xC020481A,
         IocAllocObjCtxCommand = 0xC0104809,
         IocChannelGetWaitbaseCommand = 0xC0080003,
@@ -56,6 +64,12 @@ private:
     };
     static_assert(sizeof(IoctlChannelSetTimeout) == 4, "IoctlChannelSetTimeout is incorrect size");
 
+    struct IoctlAllocGPFIFO {
+        u32_le num_entries;
+        u32_le flags;
+    };
+    static_assert(sizeof(IoctlAllocGPFIFO) == 8, "IoctlAllocGPFIFO is incorrect size");
+
     struct IoctlClientData {
         u64_le data;
     };
@@ -76,12 +90,45 @@ private:
     };
     static_assert(sizeof(IoctlSetErrorNotifier) == 24, "IoctlSetErrorNotifier is incorrect size");
 
+    struct IoctlChannelSetPriority {
+        u32_le priority;
+    };
+    static_assert(sizeof(IoctlChannelSetPriority) == 4,
+                  "IoctlChannelSetPriority is incorrect size");
+
+    struct IoctlEventIdControl {
+        u32_le cmd; // 0=disable, 1=enable, 2=clear
+        u32_le id;
+    };
+    static_assert(sizeof(IoctlEventIdControl) == 8, "IoctlEventIdControl is incorrect size");
+
+    struct IoctlGetErrorNotification {
+        u64_le timestamp;
+        u32_le info32;
+        u16_le info16;
+        u16_le status; // always 0xFFFF
+    };
+    static_assert(sizeof(IoctlGetErrorNotification) == 16,
+                  "IoctlGetErrorNotification is incorrect size");
+
     struct IoctlFence {
         u32_le id;
         u32_le value;
     };
     static_assert(sizeof(IoctlFence) == 8, "IoctlFence is incorrect size");
 
+    struct IoctlAllocGpfifoEx {
+        u32_le num_entries;
+        u32_le flags;
+        u32_le unk0;
+        u32_le unk1;
+        u32_le unk2;
+        u32_le unk3;
+        u32_le unk4;
+        u32_le unk5;
+    };
+    static_assert(sizeof(IoctlAllocGpfifoEx) == 32, "IoctlAllocGpfifoEx is incorrect size");
+
     struct IoctlAllocGpfifoEx2 {
         u32_le num_entries;   // in
         u32_le flags;         // in

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -933,7 +933,8 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, ScaleMatc
     // Use GetSurfaceSubRect instead
     ASSERT(params.width == params.stride);
 
-    ASSERT(!params.is_tiled || (params.width % 8 == 0 && params.height % 8 == 0));
+    ASSERT(!params.is_tiled ||
+           (params.GetActualWidth() % 8 == 0 && params.GetActualHeight() % 8 == 0));
 
     // Check for an exact match in existing surfaces
     Surface surface =

src/yuzu/main.cpp

@@ -335,6 +335,24 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
     }
 }
 
+bool GMainWindow::SupportsRequiredGLExtensions() {
+    QStringList unsupported_ext;
+
+    if (!GLAD_GL_ARB_program_interface_query)
+        unsupported_ext.append("ARB_program_interface_query");
+    if (!GLAD_GL_ARB_separate_shader_objects)
+        unsupported_ext.append("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_shader_storage_buffer_object)
+        unsupported_ext.append("ARB_shader_storage_buffer_object");
+    if (!GLAD_GL_ARB_vertex_attrib_binding)
+        unsupported_ext.append("ARB_vertex_attrib_binding");
+
+    for (const QString& ext : unsupported_ext)
+        NGLOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
+
+    return unsupported_ext.empty();
+}
+
 bool GMainWindow::LoadROM(const QString& filename) {
     // Shutdown previous session if the emu thread is still active...
     if (emu_thread != nullptr)
@@ -350,6 +368,14 @@ bool GMainWindow::LoadROM(const QString& filename) {
         return false;
     }
 
+    if (!SupportsRequiredGLExtensions()) {
+        QMessageBox::critical(
+            this, tr("Error while initializing OpenGL Core!"),
+            tr("Your GPU may not support one or more required OpenGL extensions. Please "
+               "ensure you have the latest graphics driver. See the log for more details."));
+        return false;
+    }
+
     Core::System& system{Core::System::GetInstance()};
 
     system.SetGPUDebugContext(debug_context);

src/yuzu/main.h

@@ -79,6 +79,7 @@ private:
     void ConnectWidgetEvents();
     void ConnectMenuEvents();
 
+    bool SupportsRequiredGLExtensions();
     bool LoadROM(const QString& filename);
     void BootGame(const QString& filename);
     void ShutdownGame();

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -78,6 +78,24 @@ void EmuWindow_SDL2::Fullscreen() {
     SDL_MaximizeWindow(render_window);
 }
 
+bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
+    std::vector<std::string> unsupported_ext;
+
+    if (!GLAD_GL_ARB_program_interface_query)
+        unsupported_ext.push_back("ARB_program_interface_query");
+    if (!GLAD_GL_ARB_separate_shader_objects)
+        unsupported_ext.push_back("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_shader_storage_buffer_object)
+        unsupported_ext.push_back("ARB_shader_storage_buffer_object");
+    if (!GLAD_GL_ARB_vertex_attrib_binding)
+        unsupported_ext.push_back("ARB_vertex_attrib_binding");
+
+    for (const std::string& ext : unsupported_ext)
+        NGLOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);
+
+    return unsupported_ext.empty();
+}
+
 EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
     InputCommon::Init();
 
@@ -128,6 +146,11 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
         exit(1);
     }
 
+    if (!SupportsRequiredGLExtensions()) {
+        NGLOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
+        exit(1);
+    }
+
     OnResize();
     OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
     SDL_PumpEvents();

src/yuzu_cmd/emu_window/emu_window_sdl2.h

@@ -46,6 +46,9 @@ private:
     /// Called when user passes the fullscreen parameter flag
     void Fullscreen();
 
+    /// Whether the GPU and driver supports the OpenGL extension required
+    bool SupportsRequiredGLExtensions();
+
     /// Called when a configuration change affects the minimal size of the window
     void OnMinimalClientAreaChangeRequest(
         const std::pair<unsigned, unsigned>& minimal_size) override;