Implement GetAvailableLanguageCodes2

src/core/hle/service/hid/hid.cpp

@@ -84,6 +84,10 @@ private:
 
         for (size_t controller = 0; controller < mem.controllers.size(); controller++) {
             for (int index = 0; index < HID_NUM_LAYOUTS; index++) {
+                // TODO(DarkLordZach): Is this layout/controller config actually invalid?
+                if (controller == Controller_Handheld && index == Layout_Single)
+                    continue;
+
                 ControllerLayout& layout = mem.controllers[controller].layouts[index];
                 layout.header.num_entries = HID_NUM_ENTRIES;
                 layout.header.max_entry_index = HID_NUM_ENTRIES - 1;

src/core/hle/service/set/set.cpp

@@ -43,6 +43,38 @@ void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
     NGLOG_DEBUG(Service_SET, "called");
 }
 
+void SET::GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    u32 id = rp.Pop<u32>();
+
+    static constexpr std::array<LanguageCode, 17> available_language_codes = {{
+        LanguageCode::JA,
+        LanguageCode::EN_US,
+        LanguageCode::FR,
+        LanguageCode::DE,
+        LanguageCode::IT,
+        LanguageCode::ES,
+        LanguageCode::ZH_CN,
+        LanguageCode::KO,
+        LanguageCode::NL,
+        LanguageCode::PT,
+        LanguageCode::RU,
+        LanguageCode::ZH_TW,
+        LanguageCode::EN_GB,
+        LanguageCode::FR_CA,
+        LanguageCode::ES_419,
+        LanguageCode::ZH_HANS,
+        LanguageCode::ZH_HANT,
+    }};
+    ctx.WriteBuffer(available_language_codes.data(), available_language_codes.size());
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u64>(available_language_codes.size()));
+
+    NGLOG_DEBUG(Service_SET, "called");
+}
+
 SET::SET() : ServiceFramework("set") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLanguageCode"},
@@ -50,7 +82,7 @@ SET::SET() : ServiceFramework("set") {
         {2, nullptr, "MakeLanguageCode"},
         {3, nullptr, "GetAvailableLanguageCodeCount"},
         {4, nullptr, "GetRegionCode"},
-        {5, nullptr, "GetAvailableLanguageCodes2"},
+        {5, &SET::GetAvailableLanguageCodes2, "GetAvailableLanguageCodes2"},
         {6, nullptr, "GetAvailableLanguageCodeCount2"},
         {7, nullptr, "GetKeyCodeMap"},
         {8, nullptr, "GetQuestFlag"},

src/core/hle/service/set/set.h

@@ -36,6 +36,8 @@ public:
 
 private:
     void GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx);
+
+    void GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Set

src/video_core/engines/shader_bytecode.h

@@ -526,6 +526,7 @@ public:
     enum class Type {
         Trivial,
         Arithmetic,
+        ArithmeticImmediate,
         ArithmeticInteger,
         ArithmeticIntegerImmediate,
         Bfe,
@@ -655,7 +656,7 @@ private:
             INST("0100110001101---", Id::FMUL_C, Type::Arithmetic, "FMUL_C"),
             INST("0101110001101---", Id::FMUL_R, Type::Arithmetic, "FMUL_R"),
             INST("0011100-01101---", Id::FMUL_IMM, Type::Arithmetic, "FMUL_IMM"),
-            INST("00011110--------", Id::FMUL32_IMM, Type::Arithmetic, "FMUL32_IMM"),
+            INST("00011110--------", Id::FMUL32_IMM, Type::ArithmeticImmediate, "FMUL32_IMM"),
             INST("0100110000010---", Id::IADD_C, Type::ArithmeticInteger, "IADD_C"),
             INST("0101110000010---", Id::IADD_R, Type::ArithmeticInteger, "IADD_R"),
             INST("0011100-00010---", Id::IADD_IMM, Type::ArithmeticInteger, "IADD_IMM"),
@@ -676,7 +677,7 @@ private:
             INST("0100110010011---", Id::MOV_C, Type::Arithmetic, "MOV_C"),
             INST("0101110010011---", Id::MOV_R, Type::Arithmetic, "MOV_R"),
             INST("0011100-10011---", Id::MOV_IMM, Type::Arithmetic, "MOV_IMM"),
-            INST("000000010000----", Id::MOV32_IMM, Type::Arithmetic, "MOV32_IMM"),
+            INST("000000010000----", Id::MOV32_IMM, Type::ArithmeticImmediate, "MOV32_IMM"),
             INST("0100110001100---", Id::FMNMX_C, Type::Arithmetic, "FMNMX_C"),
             INST("0101110001100---", Id::FMNMX_R, Type::Arithmetic, "FMNMX_R"),
             INST("0011100-01100---", Id::FMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -822,22 +822,25 @@ private:
 
         switch (opcode->GetType()) {
         case OpCode::Type::Arithmetic: {
-            std::string op_a = instr.alu.negate_a ? "-" : "";
+            std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
             if (instr.alu.abs_a) {
                 op_a = "abs(" + op_a + ')';
             }
 
-            std::string op_b = instr.alu.negate_b ? "-" : "";
+            if (instr.alu.negate_a) {
+                op_a = "-(" + op_a + ')';
+            }
+
+            std::string op_b;
 
             if (instr.is_b_imm) {
-                op_b += GetImmediate19(instr);
+                op_b = GetImmediate19(instr);
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 } else {
-                    op_b += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                    op_b = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                            GLSLRegister::Type::Float);
+                                           GLSLRegister::Type::Float);
                 }
             }
 
@@ -845,6 +848,10 @@ private:
                 op_b = "abs(" + op_b + ')';
             }
 
+            if (instr.alu.negate_b) {
+                op_b = "-(" + op_b + ')';
+            }
+
             switch (opcode->GetId()) {
             case OpCode::Id::MOV_C:
             case OpCode::Id::MOV_R: {
@@ -852,11 +859,6 @@ private:
                 break;
             }
 
-            case OpCode::Id::MOV32_IMM: {
-                // mov32i doesn't have abs or neg bits.
-                regs.SetRegisterToFloat(instr.gpr0, 0, GetImmediate32(instr), 1, 1);
-                break;
-            }
             case OpCode::Id::FMUL_C:
             case OpCode::Id::FMUL_R:
             case OpCode::Id::FMUL_IMM: {
@@ -864,13 +866,6 @@ private:
                                         instr.alu.saturate_d);
                 break;
             }
-            case OpCode::Id::FMUL32_IMM: {
-                // fmul32i doesn't have abs or neg bits.
-                regs.SetRegisterToFloat(
-                    instr.gpr0, 0,
-                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
-                break;
-            }
             case OpCode::Id::FADD_C:
             case OpCode::Id::FADD_R:
             case OpCode::Id::FADD_IMM: {
@@ -943,6 +938,21 @@ private:
             }
             break;
         }
+        case OpCode::Type::ArithmeticImmediate: {
+            switch (opcode->GetId()) {
+            case OpCode::Id::MOV32_IMM: {
+                regs.SetRegisterToFloat(instr.gpr0, 0, GetImmediate32(instr), 1, 1);
+                break;
+            }
+            case OpCode::Id::FMUL32_IMM: {
+                regs.SetRegisterToFloat(
+                    instr.gpr0, 0,
+                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
+                break;
+            }
+            }
+            break;
+        }
         case OpCode::Type::Bfe: {
             ASSERT_MSG(!instr.bfe.negate_b, "Unimplemented");