clang format

src/common/io_file.cpp

@@ -3,10 +3,10 @@
 
 #include <vector>
 
-#include "common/assert.h"
 #include "common/alignment.h"
-#include "common/io_file.h"
+#include "common/assert.h"
 #include "common/error.h"
+#include "common/io_file.h"
 #include "common/logging/log.h"
 #include "common/path_util.h"
 
@@ -224,7 +224,8 @@ void* IOFile::GetFileMapping() {
     }
     const int fd = fileno(file);
     HANDLE hfile = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-    file_mapping = CreateFileMapping2(hfile, NULL, FILE_MAP_READ, PAGE_READONLY, SEC_COMMIT, 0, NULL, NULL, 0);
+    file_mapping =
+        CreateFileMapping2(hfile, NULL, FILE_MAP_READ, PAGE_READONLY, SEC_COMMIT, 0, NULL, NULL, 0);
     ASSERT_MSG(file_mapping, "{}", Common::GetLastErrorMsg());
     return file_mapping;
 #endif

src/core/address_space.cpp

@@ -117,8 +117,8 @@ struct AddressSpace::Impl {
         void* ptr = nullptr;
         if (phys_addr != -1) {
             HANDLE backing = fd ? fd : backing_handle;
-            ptr = MapViewOfFile3(backing, process, reinterpret_cast<PVOID>(virtual_addr),
+            ptr = MapViewOfFile3(backing, process, reinterpret_cast<PVOID>(virtual_addr), phys_addr,
-                                 phys_addr, size, MEM_REPLACE_PLACEHOLDER, prot, nullptr, 0);
+                                 size, MEM_REPLACE_PLACEHOLDER, prot, nullptr, 0);
         } else {
             ptr =
                 VirtualAlloc2(process, reinterpret_cast<PVOID>(virtual_addr), size,

src/core/libraries/kernel/event_queue.h

@@ -34,12 +34,12 @@ constexpr s16 EVFILT_GPU_SYSTEM_EXCEPTION = -21;
 constexpr s16 EVFILT_GPU_DBGGC_EV = -22;
 constexpr s16 EVFILT_SYSCOUNT = 22;
 
-constexpr u16 EV_ONESHOT = 0x10;		// only report one occurrence
+constexpr u16 EV_ONESHOT = 0x10;    // only report one occurrence
-constexpr u16 EV_CLEAR = 0x20;		// clear event state after reporting
+constexpr u16 EV_CLEAR = 0x20;      // clear event state after reporting
-constexpr u16 EV_RECEIPT = 0x40;		// force EV_ERROR on success, data=0
+constexpr u16 EV_RECEIPT = 0x40;    // force EV_ERROR on success, data=0
-constexpr u16 EV_DISPATCH = 0x80;		// disable event after reporting
+constexpr u16 EV_DISPATCH = 0x80;   // disable event after reporting
-constexpr u16 EV_SYSFLAGS = 0xF000;		// reserved by system
+constexpr u16 EV_SYSFLAGS = 0xF000; // reserved by system
-constexpr u16 EV_FLAG1 = 0x2000;		// filter-specific flag
+constexpr u16 EV_FLAG1 = 0x2000;    // filter-specific flag
 
 class EqueueInternal;
 struct EqueueEvent;

src/core/libraries/kernel/libkernel.cpp

@@ -70,18 +70,20 @@ int* PS4_SYSV_ABI __Error() {
 int PS4_SYSV_ABI sceKernelMmap(void* addr, u64 len, int prot, int flags, int fd, size_t offset,
                                void** res) {
     LOG_INFO(Kernel_Vmm, "called addr = {}, len = {}, prot = {}, flags = {}, fd = {}, offset = {}",
-                         fmt::ptr(addr), len, prot, flags, fd, offset);
+             fmt::ptr(addr), len, prot, flags, fd, offset);
     auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
     auto* memory = Core::Memory::Instance();
     void* handle = NULL;
     if (fd == -1) {
-        handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, len + offset, NULL);
+        handle =
+            CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, len + offset, NULL);
     } else {
         handle = h->GetFile(fd)->f.GetFileMapping();
     }
     const auto mem_prot = static_cast<Core::MemoryProt>(prot);
     const auto mem_flags = static_cast<Core::MemoryMapFlags>(flags);
-    return memory->MapFile(res, std::bit_cast<VAddr>(addr), len, mem_prot, mem_flags, handle, offset);
+    return memory->MapFile(res, std::bit_cast<VAddr>(addr), len, mem_prot, mem_flags, handle,
+                           offset);
 }
 
 void* PS4_SYSV_ABI posix_mmap(void* addr, u64 len, int prot, int flags, int fd, u64 offset) {
@@ -214,7 +216,8 @@ struct OrbisModuleInfoForUnwind {
     u64 seg0_size;
 };
 
-s32 PS4_SYSV_ABI sceKernelGetModuleInfoForUnwind(VAddr addr, int flags, OrbisModuleInfoForUnwind* info) {
+s32 PS4_SYSV_ABI sceKernelGetModuleInfoForUnwind(VAddr addr, int flags,
+                                                 OrbisModuleInfoForUnwind* info) {
     if (flags >= 3) {
         std::memset(info, 0, sizeof(OrbisModuleInfoForUnwind));
         return SCE_KERNEL_ERROR_EINVAL;
@@ -247,7 +250,7 @@ int PS4_SYSV_ABI sceKernelDebugRaiseException() {
     return 0;
 }
 
-char PS4_SYSV_ABI _is_signal_return(s64 *param_1) {
+char PS4_SYSV_ABI _is_signal_return(s64* param_1) {
     char cVar1;
 
     if (((*param_1 != 0x48006a40247c8d48ULL) || (param_1[1] != 0x50f000001a1c0c7ULL)) ||

src/core/libraries/kernel/thread_management.cpp

@@ -9,8 +9,8 @@
 #include "common/singleton.h"
 #include "common/thread.h"
 #include "core/libraries/error_codes.h"
-#include "core/libraries/kernel/threads/threads.h"
 #include "core/libraries/kernel/thread_management.h"
+#include "core/libraries/kernel/threads/threads.h"
 #include "core/libraries/libs.h"
 #include "core/linker.h"
 #ifdef _WIN64
@@ -1122,7 +1122,7 @@ int PS4_SYSV_ABI posix_sched_get_priority_min() {
 int PS4_SYSV_ABI posix_pthread_mutex_trylock(ScePthreadMutex* mutex) {
     int result = scePthreadMutexTrylock(mutex);
     if (result < 0) {
-        //UNREACHABLE();
+        // UNREACHABLE();
     }
     return result;
 }
@@ -1166,17 +1166,17 @@ int PS4_SYSV_ABI posix_pthread_create_name_np(ScePthread* thread, const ScePthre
 }
 
 int PS4_SYSV_ABI posix_pthread_create(ScePthread* thread, const ScePthreadAttr* attr,
-                                pthreadEntryFunc start_routine, void* arg) {
+                                      pthreadEntryFunc start_routine, void* arg) {
     return posix_pthread_create_name_np(thread, attr, start_routine, arg, "NoName");
 }
 
-using Destructor = void(*)(void*);
+using Destructor = void (*)(void*);
 
 int PS4_SYSV_ABI posix_pthread_key_create(u32* key, Destructor func) {
     return pthread_key_create(key, func);
 }
 
-int PS4_SYSV_ABI posix_pthread_setspecific(int key, const void *value) {
+int PS4_SYSV_ABI posix_pthread_setspecific(int key, const void* value) {
     return pthread_setspecific(key, value);
 }
 
@@ -1217,11 +1217,13 @@ int PS4_SYSV_ABI posix_sem_post(sem_t* sem) {
     return sem_post(sem);
 }
 
-int PS4_SYSV_ABI scePthreadGetschedparam(ScePthread thread, int *policy, SceKernelSchedParam *param) {
+int PS4_SYSV_ABI scePthreadGetschedparam(ScePthread thread, int* policy,
+                                         SceKernelSchedParam* param) {
     return pthread_getschedparam(thread->pth, policy, param);
 }
 
-int PS4_SYSV_ABI scePthreadSetschedparam(ScePthread thread, int policy, const SceKernelSchedParam *param) {
+int PS4_SYSV_ABI scePthreadSetschedparam(ScePthread thread, int policy,
+                                         const SceKernelSchedParam* param) {
     return pthread_setschedparam(thread->pth, policy, param);
 }
 

src/core/libraries/libc/libc.cpp

@@ -463,10 +463,10 @@ void libcSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
 
     // stdio functions
     LIB_FUNCTION("xeYO4u7uyJ0", "libc", 1, "libc", 1, 1, ps4_fopen);
-    //LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1, ps4_printf);
+    // LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1, ps4_printf);
     LIB_FUNCTION("Q2V+iqvjgC0", "libc", 1, "libc", 1, 1, ps4_vsnprintf);
     LIB_FUNCTION("YQ0navp+YIc", "libc", 1, "libc", 1, 1, ps4_puts);
-    //LIB_FUNCTION("fffwELXNVFA", "libc", 1, "libc", 1, 1, ps4_fprintf);
+    // LIB_FUNCTION("fffwELXNVFA", "libc", 1, "libc", 1, 1, ps4_fprintf);
     LIB_FUNCTION("QMFyLoqNxIg", "libc", 1, "libc", 1, 1, ps4_setvbuf);
     LIB_FUNCTION("uodLYyUip20", "libc", 1, "libc", 1, 1, ps4_fclose);
     LIB_FUNCTION("rQFVBXp-Cxg", "libc", 1, "libc", 1, 1, ps4_fseek);

src/core/libraries/libc_internal/libc_internal.cpp

@@ -71,10 +71,14 @@ void RegisterlibSceLibcInternal(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("DfivPArhucg", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
                  internal_memcmp);
     LIB_FUNCTION("8zsu04XNsZ4", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_expf);
-    LIB_FUNCTION("aesyjrHVWy4", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_strncmp);
+    LIB_FUNCTION("aesyjrHVWy4", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
-    LIB_FUNCTION("j4ViWNHEgww", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_strlen);
+                 internal_strncmp);
-    LIB_FUNCTION("6sJWiWSRuqk", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_strncpy);
+    LIB_FUNCTION("j4ViWNHEgww", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
-    LIB_FUNCTION("gQX+4GDQjpM", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_malloc);
+                 internal_strlen);
+    LIB_FUNCTION("6sJWiWSRuqk", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_strncpy);
+    LIB_FUNCTION("gQX+4GDQjpM", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_malloc);
 };
 
 } // namespace Libraries::LibcInternal

src/core/libraries/libs.h

@@ -27,7 +27,7 @@ struct wrapper_impl<name, PS4_SYSV_ABI R (*)(Args...), f> {
             std::string_view(name.value) != "sceUserServiceGetEvent" &&
             !std::string_view(name.value).contains("mutex") &&
             !std::string_view(name.value).contains("Mutex")) {
-            //LOG_WARNING(Core_Linker, "Function {} called", name.value);
+            // LOG_WARNING(Core_Linker, "Function {} called", name.value);
         }
         if constexpr (std::is_same_v<R, s32> || std::is_same_v<R, u32>) {
             const int ret = f(args...);
@@ -45,7 +45,7 @@ template <StringLiteral name, class F, F f>
 constexpr auto wrapper = wrapper_impl<name, F, f>::wrap;
 
 #define W(foo) wrapper<#foo, decltype(&foo), foo>
-//#define W(foo) foo
+// #define W(foo) foo
 
 #define LIB_FUNCTION(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function)  \
     {                                                                                              \
@@ -57,7 +57,7 @@ constexpr auto wrapper = wrapper_impl<name, F, f>::wrap;
         sr.module_version_major = moduleVersionMajor;                                              \
         sr.module_version_minor = moduleVersionMinor;                                              \
         sr.type = Core::Loader::SymbolType::Function;                                              \
-        auto func = reinterpret_cast<u64>(W(function));                                               \
+        auto func = reinterpret_cast<u64>(W(function));                                            \
         sym->AddSymbol(sr, func);                                                                  \
     }
 

src/core/libraries/videoout/video_out.cpp

@@ -256,7 +256,8 @@ s32 sceVideoOutSubmitEopFlip(s32 handle, u32 buf_id, u32 mode, u32 arg, void** u
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceVideoOutGetDeviceCapabilityInfo(s32 handle, SceVideoOutDeviceCapabilityInfo *pDeviceCapabilityInfo) {
+s32 PS4_SYSV_ABI sceVideoOutGetDeviceCapabilityInfo(
+    s32 handle, SceVideoOutDeviceCapabilityInfo* pDeviceCapabilityInfo) {
     pDeviceCapabilityInfo->capability = 0;
     return ORBIS_OK;
 }

src/core/linker.cpp

@@ -120,7 +120,9 @@ Module* Linker::FindByAddress(VAddr address) {
 
 void Linker::Relocate(Module* module) {
     module->ForEachRelocation([&](elf_relocation* rel, u32 i, bool isJmpRel) {
-        const u32 bit_idx = (isJmpRel ? module->dynamic_info.relocation_table_size / sizeof(elf_relocation) : 0) + i;
+        const u32 bit_idx =
+            (isJmpRel ? module->dynamic_info.relocation_table_size / sizeof(elf_relocation) : 0) +
+            i;
         if (module->TestRelaBit(bit_idx)) {
             return;
         }

src/core/loader/dwarf.cpp

@@ -14,10 +14,9 @@ T get(uintptr_t addr) {
     return val;
 }
 
-static uintptr_t getEncodedP(uintptr_t& addr, uintptr_t end, u8 encoding,
+static uintptr_t getEncodedP(uintptr_t& addr, uintptr_t end, u8 encoding, uintptr_t datarelBase) {
-                             uintptr_t datarelBase) {
     const uintptr_t startAddr = addr;
-    const u8 *p = (u8*)addr;
+    const u8* p = (u8*)addr;
     uintptr_t result;
 
     // First get value
@@ -109,16 +108,17 @@ bool DecodeEHHdr(uintptr_t ehHdrStart, uintptr_t ehHdrEnd, EHHeaderInfo& ehHdrIn
         if (ehHdrEnd == ehHdrStart) {
             return false;
         }
-        LOG_ERROR(Core_Linker, "Unsupported .eh_frame_hdr at {:#x} "
+        LOG_ERROR(Core_Linker,
-                               "need at least 4 bytes of data but only got {:#x}",
+                  "Unsupported .eh_frame_hdr at {:#x} "
+                  "need at least 4 bytes of data but only got {:#x}",
                   ehHdrStart, ehHdrEnd - ehHdrStart);
         return false;
     }
 
     const u8 version = get<u8>(p++);
     if (version != 1) {
-        LOG_CRITICAL(Core_Linker, "Unsupported .eh_frame_hdr version: {:#x} at {:#x}",
+        LOG_CRITICAL(Core_Linker, "Unsupported .eh_frame_hdr version: {:#x} at {:#x}", version,
-                     version, ehHdrStart);
+                     ehHdrStart);
         return false;
     }
 
@@ -128,9 +128,7 @@ bool DecodeEHHdr(uintptr_t ehHdrStart, uintptr_t ehHdrEnd, EHHeaderInfo& ehHdrIn
 
     ehHdrInfo.eh_frame_ptr = getEncodedP(p, ehHdrEnd, eh_frame_ptr_enc, ehHdrStart);
     ehHdrInfo.fde_count =
-        fde_count_enc == DW_EH_PE_omit
+        fde_count_enc == DW_EH_PE_omit ? 0 : getEncodedP(p, ehHdrEnd, fde_count_enc, ehHdrStart);
-            ? 0
-            : getEncodedP(p, ehHdrEnd, fde_count_enc, ehHdrStart);
     ehHdrInfo.table = p;
 
     return true;

src/core/loader/dwarf.h

@@ -8,24 +8,24 @@
 namespace Dwarf {
 
 enum {
-    DW_EH_PE_ptr       = 0x00,
+    DW_EH_PE_ptr = 0x00,
-    DW_EH_PE_uleb128   = 0x01,
+    DW_EH_PE_uleb128 = 0x01,
-    DW_EH_PE_udata2    = 0x02,
+    DW_EH_PE_udata2 = 0x02,
-    DW_EH_PE_udata4    = 0x03,
+    DW_EH_PE_udata4 = 0x03,
-    DW_EH_PE_udata8    = 0x04,
+    DW_EH_PE_udata8 = 0x04,
-    DW_EH_PE_signed    = 0x08,
+    DW_EH_PE_signed = 0x08,
-    DW_EH_PE_sleb128   = 0x09,
+    DW_EH_PE_sleb128 = 0x09,
-    DW_EH_PE_sdata2    = 0x0A,
+    DW_EH_PE_sdata2 = 0x0A,
-    DW_EH_PE_sdata4    = 0x0B,
+    DW_EH_PE_sdata4 = 0x0B,
-    DW_EH_PE_sdata8    = 0x0C,
+    DW_EH_PE_sdata8 = 0x0C,
-    DW_EH_PE_absptr    = 0x00,
+    DW_EH_PE_absptr = 0x00,
-    DW_EH_PE_pcrel     = 0x10,
+    DW_EH_PE_pcrel = 0x10,
-    DW_EH_PE_textrel   = 0x20,
+    DW_EH_PE_textrel = 0x20,
-    DW_EH_PE_datarel   = 0x30,
+    DW_EH_PE_datarel = 0x30,
-    DW_EH_PE_funcrel   = 0x40,
+    DW_EH_PE_funcrel = 0x40,
-    DW_EH_PE_aligned   = 0x50,
+    DW_EH_PE_aligned = 0x50,
-    DW_EH_PE_indirect  = 0x80,
+    DW_EH_PE_indirect = 0x80,
-    DW_EH_PE_omit      = 0xFF
+    DW_EH_PE_omit = 0xFF
 };
 
 /// Information encoded in the EH frame header.
@@ -36,6 +36,6 @@ struct EHHeaderInfo {
     u8 table_enc;
 };
 
-bool DecodeEHHdr(uintptr_t ehHdrStart, uintptr_t ehHdrEnd, EHHeaderInfo &ehHdrInfo);
+bool DecodeEHHdr(uintptr_t ehHdrStart, uintptr_t ehHdrEnd, EHHeaderInfo& ehHdrInfo);
 
 } // namespace Dwarf

src/core/module.cpp

@@ -180,7 +180,7 @@ void Module::LoadModuleToMemory(u32& max_tls_index) {
                 if (eh_frame_hdr_addr > eh_frame_addr) {
                     eh_frame_size = (eh_frame_hdr_addr - eh_frame_addr);
                 } else {
-                    eh_frame_size = (aligned_base_size-eh_frame_hdr_addr);
+                    eh_frame_size = (aligned_base_size - eh_frame_hdr_addr);
                 }
             }
             break;

src/emulator.cpp

@@ -135,8 +135,10 @@ void Emulator::LoadSystemModules(const std::filesystem::path& file) {
     return;
     const auto& sys_module_path = Common::FS::GetUserPath(Common::FS::PathType::SysModuleDir);
     for (const auto& entry : std::filesystem::directory_iterator(sys_module_path)) {
-        if (/*entry.path().filename() == "libSceNgs2.sprx" || entry.path().filename() == "libSceRtc.sprx" ||
+        if (/*entry.path().filename() == "libSceNgs2.sprx" || entry.path().filename() ==
-            entry.path().filename() == "libSceDiscMap.sprx" || entry.path().filename() == "libSceLibcInternal.sprx"*/false) {
+            "libSceRtc.sprx" || entry.path().filename() == "libSceDiscMap.sprx" ||
+            entry.path().filename() == "libSceLibcInternal.sprx"*/
+            false) {
             LOG_INFO(Loader, "Loading {}", entry.path().string().c_str());
             linker->LoadModule(entry.path());
         }

src/shader_recompiler/frontend/translate/vector_alu.cpp

@@ -15,7 +15,8 @@ void Translator::V_SAD(const GcnInst& inst) {
 }
 
 void Translator::V_MAC_F32(const GcnInst& inst) {
-    SetDst(inst.dst[0], ir.FPFma(GetSrc(inst.src[0], true), GetSrc(inst.src[1], true), GetSrc(inst.dst[0], true)));
+    SetDst(inst.dst[0], ir.FPFma(GetSrc(inst.src[0], true), GetSrc(inst.src[1], true),
+                                 GetSrc(inst.dst[0], true)));
 }
 
 void Translator::V_CVT_PKRTZ_F16_F32(const GcnInst& inst) {

src/video_core/amdgpu/resource.h

@@ -281,7 +281,8 @@ struct Sampler {
     };
 
     float LodBias() const noexcept {
-        return static_cast<float>(static_cast<int16_t>((lod_bias.Value() ^ 0x2000u) - 0x2000u)) / 256.0f;
+        return static_cast<float>(static_cast<int16_t>((lod_bias.Value() ^ 0x2000u) - 0x2000u)) /
+               256.0f;
     }
 
     float MinLod() const noexcept {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -6,9 +6,9 @@
 #include "core/file_format/splash.h"
 #include "core/libraries/system/systemservice.h"
 #include "sdl_window.h"
-#include "video_core/texture_cache/image.h"
 #include "video_core/renderer_vulkan/renderer_vulkan.h"
 #include "video_core/renderer_vulkan/vk_rasterizer.h"
+#include "video_core/texture_cache/image.h"
 
 #include <vk_mem_alloc.h>
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -78,7 +78,7 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul
         .depthClampEnable = false,
         .rasterizerDiscardEnable = false,
         .polygonMode = LiverpoolToVK::PolygonMode(key.polygon_mode),
-        .cullMode = vk::CullModeFlagBits::eNone/*LiverpoolToVK::CullMode(key.cull_mode)*/,
+        .cullMode = vk::CullModeFlagBits::eNone /*LiverpoolToVK::CullMode(key.cull_mode)*/,
         .frontFace = key.front_face == Liverpool::FrontFace::Clockwise
                          ? vk::FrontFace::eClockwise
                          : vk::FrontFace::eCounterClockwise,

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -6,9 +6,9 @@
 #include "common/io_file.h"
 #include "common/path_util.h"
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
+#include "shader_recompiler/exception.h"
 #include "shader_recompiler/recompiler.h"
 #include "shader_recompiler/runtime_info.h"
-#include "shader_recompiler/exception.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"

src/video_core/texture_cache/image_view.cpp

@@ -46,7 +46,8 @@ vk::ComponentSwizzle ConvertComponentSwizzle(u32 dst_sel) {
     }
 }
 
-ImageViewInfo::ImageViewInfo(const AmdGpu::Image& image, bool is_storage) noexcept : is_storage{is_storage} {
+ImageViewInfo::ImageViewInfo(const AmdGpu::Image& image, bool is_storage) noexcept
+    : is_storage{is_storage} {
     type = ConvertImageViewType(image.type);
     format = Vulkan::LiverpoolToVK::SurfaceFormat(image.GetDataFmt(), image.GetNumberFmt());
     range.base.level = 0;