7 files changed, 58 insertions, 31 deletions

diff --git a/src/citra_qt/main.cpp b/src/citra_qt/main.cpp
index 57adbc136..32cceaf7e 100644
--- a/src/citra_qt/main.cpp
+++ b/src/citra_qt/main.cpp
@@ -310,6 +310,7 @@ bool GMainWindow::LoadROM(const std::string& filename) {
 
 void GMainWindow::BootGame(const std::string& filename) {
     LOG_INFO(Frontend, "Citra starting...");
+    StoreRecentFile(filename); // Put the filename on top of the list
 
     if (!InitializeSystem())
         return;
@@ -374,11 +375,11 @@ void GMainWindow::ShutdownGame() {
     emulation_running = false;
 }
 
-void GMainWindow::StoreRecentFile(const QString& filename)
+void GMainWindow::StoreRecentFile(const std::string& filename)
 {
     QSettings settings;
     QStringList recent_files = settings.value("recentFiles").toStringList();
-    recent_files.prepend(filename);
+    recent_files.prepend(QString::fromStdString(filename));
     recent_files.removeDuplicates();
     while (recent_files.size() > max_recent_files_item) {
         recent_files.removeLast();
@@ -426,7 +427,6 @@ void GMainWindow::OnMenuLoadFile() {
     QString filename = QFileDialog::getOpenFileName(this, tr("Load File"), rom_path, tr("3DS executable (*.3ds *.3dsx *.elf *.axf *.cci *.cxi)"));
     if (!filename.isEmpty()) {
         settings.setValue("romsPath", QFileInfo(filename).path());
-        StoreRecentFile(filename);
 
         BootGame(filename.toLocal8Bit().data());
     }
@@ -462,7 +462,6 @@ void GMainWindow::OnMenuRecentFile() {
     QFileInfo file_info(filename);
     if (file_info.exists()) {
         BootGame(filename.toLocal8Bit().data());
-        StoreRecentFile(filename); // Put the filename on top of the list
     } else {
         // Display an error message and remove the file from the list.
         QMessageBox::information(this, tr("File not found"), tr("File \"%1\" not found").arg(filename));
diff --git a/src/citra_qt/main.h b/src/citra_qt/main.h
index 945aea0cd..6e4e56689 100644
--- a/src/citra_qt/main.h
+++ b/src/citra_qt/main.h
@@ -75,7 +75,7 @@ private:
      *
      * @param filename the filename to store
      */
-    void StoreRecentFile(const QString& filename);
+    void StoreRecentFile(const std::string& filename);
 
     /**
      * Updates the recent files menu.
diff --git a/src/common/vector_math.h b/src/common/vector_math.h
index 02688e35e..cfb9481b6 100644
--- a/src/common/vector_math.h
+++ b/src/common/vector_math.h
@@ -447,7 +447,10 @@ public:
 
     void SetZero()
     {
-        x=0; y=0; z=0;
+        x = 0;
+        y = 0;
+        z = 0;
+        w = 0;
     }
 
     // Common alias: RGBA (colors)
diff --git a/src/core/hle/service/fs/fs_user.cpp b/src/core/hle/service/fs/fs_user.cpp
index 632620a56..e6c1f3616 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -707,6 +707,30 @@ static void GetPriority(Service::Interface* self) {
     LOG_DEBUG(Service_FS, "called priority=0x%X", priority);
 }
 
+/**
+ * FS_User::GetArchiveResource service function.
+ *  Inputs:
+ *      0 : 0x08490040
+ *      1 : Media type
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ *      2 : Sector byte-size
+ *      3 : Cluster byte-size
+ *      4 : Partition capacity in clusters
+ *      5 : Available free space in clusters
+ */
+static void GetArchiveResource(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    LOG_WARNING(Service_FS, "(STUBBED) called Media type=0x%08X", cmd_buff[1]);
+
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 512;
+    cmd_buff[3] = 16384;
+    cmd_buff[4] = 0x80000; // 8GiB capacity
+    cmd_buff[5] = 0x80000; // 8GiB free
+}
+
 const Interface::FunctionInfo FunctionTable[] = {
     {0x000100C6, nullptr,                  "Dummy1"},
     {0x040100C4, nullptr,                  "Control"},
@@ -782,7 +806,7 @@ const Interface::FunctionInfo FunctionTable[] = {
     {0x08460102, nullptr,                  "GetLegacyRomHeader2"},
     {0x08470180, nullptr,                  "FormatCtrCardUserSaveData"},
     {0x08480042, nullptr,                  "GetSdmcCtrRootPath"},
-    {0x08490040, nullptr,                  "GetArchiveResource"},
+    {0x08490040, GetArchiveResource,       "GetArchiveResource"},
     {0x084A0002, nullptr,                  "ExportIntegrityVerificationSeed"},
     {0x084B0002, nullptr,                  "ImportIntegrityVerificationSeed"},
     {0x084C0242, FormatSaveData,           "FormatSaveData"},
diff --git a/src/video_core/command_processor.cpp b/src/video_core/command_processor.cpp
index 54721561e..4b59984ad 100644
--- a/src/video_core/command_processor.cpp
+++ b/src/video_core/command_processor.cpp
@@ -200,7 +200,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
             for (int loader = 0; loader < 12; ++loader) {
                 const auto& loader_config = attribute_config.attribute_loaders[loader];
 
-                u32 load_address = base_address + loader_config.data_offset;
+                u32 offset = 0;
 
                 // TODO: What happens if a loader overwrites a previous one's data?
                 for (unsigned component = 0; component < loader_config.component_count; ++component) {
@@ -212,17 +212,17 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
                     u32 attribute_index = loader_config.GetComponent(component);
                     if (attribute_index < 12) {
                         int element_size = attribute_config.GetElementSizeInBytes(attribute_index);
-                        load_address = Common::AlignUp(load_address, element_size);
-                        vertex_attribute_sources[attribute_index] = load_address;
+                        offset = Common::AlignUp(offset, element_size);
+                        vertex_attribute_sources[attribute_index] = base_address + loader_config.data_offset + offset;
                         vertex_attribute_strides[attribute_index] = static_cast<u32>(loader_config.byte_count);
                         vertex_attribute_formats[attribute_index] = attribute_config.GetFormat(attribute_index);
                         vertex_attribute_elements[attribute_index] = attribute_config.GetNumElements(attribute_index);
                         vertex_attribute_element_size[attribute_index] = element_size;
-                        load_address += attribute_config.GetStride(attribute_index);
+                        offset += attribute_config.GetStride(attribute_index);
                     } else if (attribute_index < 16) {
                         // Attribute ids 12, 13, 14 and 15 signify 4, 8, 12 and 16-byte paddings, respectively
-                        load_address = Common::AlignUp(load_address, 4);
-                        load_address += (attribute_index - 11) * 4;
+                        offset = Common::AlignUp(offset, 4);
+                        offset += (attribute_index - 11) * 4;
                     } else {
                         UNREACHABLE(); // This is truly unreachable due to the number of bits for each component
                     }
@@ -234,7 +234,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
 
             const auto& index_info = regs.index_array;
             const u8* index_address_8 = Memory::GetPhysicalPointer(base_address + index_info.offset);
-            const u16* index_address_16 = (u16*)index_address_8;
+            const u16* index_address_16 = reinterpret_cast<const u16*>(index_address_8);
             bool index_u16 = index_info.format != 0;
 
 #if PICA_DUMP_GEOMETRY
@@ -345,10 +345,11 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
                                         : (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::SHORT) ? 2 : 1);
                                 }
 
-                                const float srcval = (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::BYTE) ? *(s8*)srcdata :
-                                    (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::UBYTE) ? *(u8*)srcdata :
-                                    (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::SHORT) ? *(s16*)srcdata :
-                                    *(float*)srcdata;
+                                const float srcval =
+                                    (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::BYTE)  ? *reinterpret_cast<const s8*>(srcdata) :
+                                    (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::UBYTE) ? *reinterpret_cast<const u8*>(srcdata) :
+                                    (vertex_attribute_formats[i] == Regs::VertexAttributeFormat::SHORT) ? *reinterpret_cast<const s16*>(srcdata) :
+                                    *reinterpret_cast<const float*>(srcdata);
 
                                 input.attr[i][comp] = float24::FromFloat32(srcval);
                                 LOG_TRACE(HW_GPU, "Loaded component %x of attribute %x for vertex %x (index %x) from 0x%08x + 0x%08x + 0x%04x: %f",
diff --git a/src/video_core/debug_utils/debug_utils.cpp b/src/video_core/debug_utils/debug_utils.cpp
index 271e81ca1..bac6d69c7 100644
--- a/src/video_core/debug_utils/debug_utils.cpp
+++ b/src/video_core/debug_utils/debug_utils.cpp
@@ -117,13 +117,13 @@ void GeometryDumper::Dump() {
 void DumpShader(const std::string& filename, const Regs::ShaderConfig& config, const Shader::ShaderSetup& setup, const Regs::VSOutputAttributes* output_attributes)
 {
     struct StuffToWrite {
-        u8* pointer;
+        const u8* pointer;
         u32 size;
     };
     std::vector<StuffToWrite> writing_queue;
     u32 write_offset = 0;
 
-    auto QueueForWriting = [&writing_queue,&write_offset](u8* pointer, u32 size) {
+    auto QueueForWriting = [&writing_queue,&write_offset](const u8* pointer, u32 size) {
         writing_queue.push_back({pointer, size});
         u32 old_write_offset = write_offset;
         write_offset += size;
@@ -228,27 +228,27 @@ void DumpShader(const std::string& filename, const Regs::ShaderConfig& config, c
     DVLPHeader dvlp{ DVLPHeader::MAGIC_WORD };
     DVLEHeader dvle{ DVLEHeader::MAGIC_WORD };
 
-    QueueForWriting((u8*)&dvlb, sizeof(dvlb));
-    u32 dvlp_offset = QueueForWriting((u8*)&dvlp, sizeof(dvlp));
-    dvlb.dvle_offset = QueueForWriting((u8*)&dvle, sizeof(dvle));
+    QueueForWriting(reinterpret_cast<const u8*>(&dvlb), sizeof(dvlb));
+    u32 dvlp_offset = QueueForWriting(reinterpret_cast<const u8*>(&dvlp), sizeof(dvlp));
+    dvlb.dvle_offset = QueueForWriting(reinterpret_cast<const u8*>(&dvle), sizeof(dvle));
 
     // TODO: Reduce the amount of binary code written to relevant portions
     dvlp.binary_offset = write_offset - dvlp_offset;
     dvlp.binary_size_words = setup.program_code.size();
-    QueueForWriting((u8*)setup.program_code.data(), setup.program_code.size() * sizeof(u32));
+    QueueForWriting(reinterpret_cast<const u8*>(setup.program_code.data()), setup.program_code.size() * sizeof(u32));
 
     dvlp.swizzle_info_offset = write_offset - dvlp_offset;
     dvlp.swizzle_info_num_entries = setup.swizzle_data.size();
     u32 dummy = 0;
     for (unsigned int i = 0; i < setup.swizzle_data.size(); ++i) {
-        QueueForWriting((u8*)&setup.swizzle_data[i], sizeof(setup.swizzle_data[i]));
-        QueueForWriting((u8*)&dummy, sizeof(dummy));
+        QueueForWriting(reinterpret_cast<const u8*>(&setup.swizzle_data[i]), sizeof(setup.swizzle_data[i]));
+        QueueForWriting(reinterpret_cast<const u8*>(&dummy), sizeof(dummy));
     }
 
     dvle.main_offset_words = config.main_offset;
     dvle.output_register_table_offset = write_offset - dvlb.dvle_offset;
     dvle.output_register_table_size = static_cast<u32>(output_info_table.size());
-    QueueForWriting((u8*)output_info_table.data(), static_cast<u32>(output_info_table.size() * sizeof(OutputRegisterInfo)));
+    QueueForWriting(reinterpret_cast<const u8*>(output_info_table.data()), static_cast<u32>(output_info_table.size() * sizeof(OutputRegisterInfo)));
 
     // TODO: Create a label table for "main"
 
@@ -292,14 +292,14 @@ void DumpShader(const std::string& filename, const Regs::ShaderConfig& config, c
     dvle.constant_table_offset = write_offset - dvlb.dvle_offset;
     dvle.constant_table_size = constant_table.size();
     for (const auto& constant : constant_table) {
-        QueueForWriting((uint8_t*)&constant, sizeof(constant));
+        QueueForWriting(reinterpret_cast<const u8*>(&constant), sizeof(constant));
     }
 
     // Write data to file
     std::ofstream file(filename, std::ios_base::out | std::ios_base::binary);
 
-    for (auto& chunk : writing_queue) {
-        file.write((char*)chunk.pointer, chunk.size);
+    for (const auto& chunk : writing_queue) {
+        file.write(reinterpret_cast<const char*>(chunk.pointer), chunk.size);
     }
 }
 
diff --git a/src/video_core/shader/shader_interpreter.cpp b/src/video_core/shader/shader_interpreter.cpp
index 2dc8d5d5e..9b978583e 100644
--- a/src/video_core/shader/shader_interpreter.cpp
+++ b/src/video_core/shader/shader_interpreter.cpp
@@ -407,7 +407,7 @@ void RunInterpreter(UnitState<Debug>& state) {
         {
             if ((instr.opcode.Value().EffectiveOpCode() == OpCode::Id::MAD) ||
                 (instr.opcode.Value().EffectiveOpCode() == OpCode::Id::MADI)) {
-                const SwizzlePattern& swizzle = *(SwizzlePattern*)&swizzle_data[instr.mad.operand_desc_id];
+                const SwizzlePattern& swizzle = *reinterpret_cast<const SwizzlePattern*>(&swizzle_data[instr.mad.operand_desc_id]);
 
                 bool is_inverted = (instr.opcode.Value().EffectiveOpCode() == OpCode::Id::MADI);