From e0dbad7204e212a6380e30f52266848f38566a4a Mon Sep 17 00:00:00 2001 From: xbzk Date: Mon, 9 Feb 2026 19:03:57 -0300 Subject: [PATCH] unswizzle combo picker core --- .../features/settings/model/BooleanSetting.kt | 1 + .../model/view/GpuUnswizzleSetting.kt | 74 +++++++ .../settings/model/view/SettingsItem.kt | 13 ++ .../settings/ui/GpuUnswizzleDialogFragment.kt | 206 ++++++++++++++++++ .../features/settings/ui/SettingsAdapter.kt | 15 +- .../settings/ui/SettingsFragmentPresenter.kt | 4 +- .../ui/viewholder/GpuUnswizzleViewHolder.kt | 71 ++++++ .../main/res/layout/dialog_gpu_unswizzle.xml | 96 ++++++++ .../app/src/main/res/values/strings.xml | 5 + src/common/settings.h | 3 + 10 files changed, 484 insertions(+), 4 deletions(-) create mode 100644 src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/GpuUnswizzleSetting.kt create mode 100644 src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/GpuUnswizzleDialogFragment.kt create mode 100644 src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/viewholder/GpuUnswizzleViewHolder.kt create mode 100644 src/android/app/src/main/res/layout/dialog_gpu_unswizzle.xml diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt index 996c67367f..eca1d00fbe 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt @@ -33,6 +33,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting { RENDERER_PROVOKING_VERTEX("provoking_vertex"), RENDERER_DESCRIPTOR_INDEXING("descriptor_indexing"), RENDERER_SAMPLE_SHADING("sample_shading"), + GPU_UNSWIZZLE_ENABLED("gpu_unswizzle_enabled"), PICTURE_IN_PICTURE("picture_in_picture"), USE_CUSTOM_RTC("custom_rtc_enabled"), BLACK_BACKGROUNDS("black_backgrounds"), diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/GpuUnswizzleSetting.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/GpuUnswizzleSetting.kt new file mode 100644 index 0000000000..c83c20a46f --- /dev/null +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/GpuUnswizzleSetting.kt @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +package org.yuzu.yuzu_emu.features.settings.model.view + +import androidx.annotation.ArrayRes +import androidx.annotation.StringRes +import org.yuzu.yuzu_emu.features.settings.model.AbstractSetting +import org.yuzu.yuzu_emu.features.settings.model.BooleanSetting +import org.yuzu.yuzu_emu.features.settings.model.IntSetting + +class GpuUnswizzleSetting( + @StringRes titleId: Int = 0, + titleString: String = "", + @StringRes descriptionId: Int = 0, + descriptionString: String = "", + @ArrayRes val textureSizeChoicesId: Int, + @ArrayRes val textureSizeValuesId: Int, + @ArrayRes val streamSizeChoicesId: Int, + @ArrayRes val streamSizeValuesId: Int, + @ArrayRes val chunkSizeChoicesId: Int, + @ArrayRes val chunkSizeValuesId: Int +) : SettingsItem( + object : AbstractSetting { + override val key: String = "gpu_unswizzle_combined" + override val defaultValue: Any = false + override val isSaveable = true + override val isRuntimeModifiable = false + override fun getValueAsString(needsGlobal: Boolean): String = "combined" + override fun reset() { + BooleanSetting.GPU_UNSWIZZLE_ENABLED.reset() + IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.reset() + IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.reset() + IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.reset() + } + }, + titleId, + titleString, + descriptionId, + descriptionString +) { + override val type = SettingsItem.TYPE_GPU_UNSWIZZLE + + // Check if GPU unswizzle is enabled via the dedicated boolean setting + fun isEnabled(needsGlobal: Boolean = false): Boolean = + BooleanSetting.GPU_UNSWIZZLE_ENABLED.getBoolean(needsGlobal) + + fun setEnabled(value: Boolean) = + BooleanSetting.GPU_UNSWIZZLE_ENABLED.setBoolean(value) + + fun enable() = setEnabled(true) + + fun disable() = setEnabled(false) + + fun getTextureSize(needsGlobal: Boolean = false): Int = + IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.getInt(needsGlobal) + + fun setTextureSize(value: Int) = + IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.setInt(value) + + fun getStreamSize(needsGlobal: Boolean = false): Int = + IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.getInt(needsGlobal) + + fun setStreamSize(value: Int) = + IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.setInt(value) + + fun getChunkSize(needsGlobal: Boolean = false): Int = + IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.getInt(needsGlobal) + + fun setChunkSize(value: Int) = + IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.setInt(value) + + fun reset() = setting.reset() +} \ No newline at end of file diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt index 8bb618289e..6338374aa9 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt @@ -104,6 +104,7 @@ abstract class SettingsItem( const val TYPE_SPINBOX = 12 const val TYPE_LAUNCHABLE = 13 const val TYPE_PATH = 14 + const val TYPE_GPU_UNSWIZZLE = 15 const val FASTMEM_COMBINED = "fastmem_combined" @@ -684,6 +685,18 @@ abstract class SettingsItem( valuesId = R.array.gpuSwizzleChunkValues ) ) + put( + GpuUnswizzleSetting( + titleId = R.string.gpu_unswizzle_settings, + descriptionId = R.string.gpu_unswizzle_settings_description, + textureSizeChoicesId = R.array.gpuTextureSizeSwizzleEntries, + textureSizeValuesId = R.array.gpuTextureSizeSwizzleValues, + streamSizeChoicesId = R.array.gpuSwizzleEntries, + streamSizeValuesId = R.array.gpuSwizzleValues, + chunkSizeChoicesId = R.array.gpuSwizzleChunkEntries, + chunkSizeValuesId = R.array.gpuSwizzleChunkValues + ) + ) put( SingleChoiceSetting( IntSetting.FAST_CPU_TIME, diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/GpuUnswizzleDialogFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/GpuUnswizzleDialogFragment.kt new file mode 100644 index 0000000000..e14bc7639e --- /dev/null +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/GpuUnswizzleDialogFragment.kt @@ -0,0 +1,206 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +package org.yuzu.yuzu_emu.features.settings.ui + +import android.app.Dialog +import android.content.DialogInterface +import android.os.Bundle +import android.view.LayoutInflater +import android.widget.ArrayAdapter +import androidx.fragment.app.DialogFragment +import androidx.fragment.app.activityViewModels +import com.google.android.material.dialog.MaterialAlertDialogBuilder +import org.yuzu.yuzu_emu.R +import org.yuzu.yuzu_emu.databinding.DialogGpuUnswizzleBinding +import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting + +class GpuUnswizzleDialogFragment : DialogFragment() { + private var position = 0 + private val settingsViewModel: SettingsViewModel by activityViewModels() + private lateinit var binding: DialogGpuUnswizzleBinding + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + position = requireArguments().getInt(POSITION) + + if (settingsViewModel.clickedItem == null) dismiss() + } + + override fun onCreateDialog(savedInstanceState: Bundle?): Dialog { + binding = DialogGpuUnswizzleBinding.inflate(LayoutInflater.from(requireContext())) + val item = settingsViewModel.clickedItem as GpuUnswizzleSetting + + // Setup texture size dropdown + val textureSizeEntries = resources.getStringArray(item.textureSizeChoicesId) + val textureSizeValues = resources.getIntArray(item.textureSizeValuesId) + val textureSizeAdapter = ArrayAdapter( + requireContext(), + android.R.layout.simple_dropdown_item_1line, + textureSizeEntries.toMutableList() + ) + binding.dropdownTextureSize.setAdapter(textureSizeAdapter) + + // Setup stream size dropdown + val streamSizeEntries = resources.getStringArray(item.streamSizeChoicesId) + val streamSizeValues = resources.getIntArray(item.streamSizeValuesId) + val streamSizeAdapter = ArrayAdapter( + requireContext(), + android.R.layout.simple_dropdown_item_1line, + streamSizeEntries.toMutableList() + ) + binding.dropdownStreamSize.setAdapter(streamSizeAdapter) + + // Setup chunk size dropdown + val chunkSizeEntries = resources.getStringArray(item.chunkSizeChoicesId) + val chunkSizeValues = resources.getIntArray(item.chunkSizeValuesId) + val chunkSizeAdapter = ArrayAdapter( + requireContext(), + android.R.layout.simple_dropdown_item_1line, + chunkSizeEntries.toMutableList() + ) + binding.dropdownChunkSize.setAdapter(chunkSizeAdapter) + + // Load current values + val isEnabled = item.isEnabled() + binding.switchEnable.isChecked = isEnabled + + if (isEnabled) { + val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize()) + if (textureSizeIndex >= 0) { + binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false) + } + + val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize()) + if (streamSizeIndex >= 0) { + binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false) + } + + val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize()) + if (chunkSizeIndex >= 0) { + binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false) + } + } else { + // Set default/recommended values when disabling + binding.dropdownTextureSize.setText(textureSizeEntries[3], false) + binding.dropdownStreamSize.setText(streamSizeEntries[3], false) + binding.dropdownChunkSize.setText(chunkSizeEntries[3], false) + } + + // Clear adapter filters after setText to fix rotation bug + textureSizeAdapter.filter.filter(null) + streamSizeAdapter.filter.filter(null) + chunkSizeAdapter.filter.filter(null) + + // Enable/disable dropdowns based on switch state + updateDropdownsState(isEnabled) + binding.switchEnable.setOnCheckedChangeListener { _, checked -> + updateDropdownsState(checked) + } + + val dialog = MaterialAlertDialogBuilder(requireContext()) + .setTitle(item.title) + .setView(binding.root) + .create() + + // Setup button listeners + binding.btnDefault.setOnClickListener { + // Reset to defaults + item.reset() + // Refresh values with adapters reset + val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize()) + if (textureSizeIndex >= 0) { + binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false) + } + val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize()) + if (streamSizeIndex >= 0) { + binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false) + } + val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize()) + if (chunkSizeIndex >= 0) { + binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false) + } + // Clear filters + textureSizeAdapter.filter.filter(null) + streamSizeAdapter.filter.filter(null) + chunkSizeAdapter.filter.filter(null) + + settingsViewModel.setAdapterItemChanged(position) + settingsViewModel.setShouldReloadSettingsList(true) + } + + binding.btnCancel.setOnClickListener { + dialog.dismiss() + } + + binding.btnOk.setOnClickListener { + if (binding.switchEnable.isChecked) { + item.enable() + // Save the selected values + val selectedTextureIndex = textureSizeEntries.indexOf( + binding.dropdownTextureSize.text.toString() + ) + if (selectedTextureIndex >= 0) { + item.setTextureSize(textureSizeValues[selectedTextureIndex]) + } + + val selectedStreamIndex = streamSizeEntries.indexOf( + binding.dropdownStreamSize.text.toString() + ) + if (selectedStreamIndex >= 0) { + item.setStreamSize(streamSizeValues[selectedStreamIndex]) + } + + val selectedChunkIndex = chunkSizeEntries.indexOf( + binding.dropdownChunkSize.text.toString() + ) + if (selectedChunkIndex >= 0) { + item.setChunkSize(chunkSizeValues[selectedChunkIndex]) + } + } else { + // Disable GPU unswizzle + item.disable() + } + + settingsViewModel.setAdapterItemChanged(position) + settingsViewModel.setShouldReloadSettingsList(true) + dialog.dismiss() + } + + // Ensure filters are cleared after dialog is shown + binding.root.post { + textureSizeAdapter.filter.filter(null) + streamSizeAdapter.filter.filter(null) + chunkSizeAdapter.filter.filter(null) + } + + return dialog + } + + private fun updateDropdownsState(enabled: Boolean) { + binding.layoutTextureSize.isEnabled = enabled + binding.dropdownTextureSize.isEnabled = enabled + binding.layoutStreamSize.isEnabled = enabled + binding.dropdownStreamSize.isEnabled = enabled + binding.layoutChunkSize.isEnabled = enabled + binding.dropdownChunkSize.isEnabled = enabled + } + + companion object { + const val TAG = "GpuUnswizzleDialogFragment" + const val POSITION = "Position" + + fun newInstance( + settingsViewModel: SettingsViewModel, + item: GpuUnswizzleSetting, + position: Int + ): GpuUnswizzleDialogFragment { + val dialog = GpuUnswizzleDialogFragment() + val args = Bundle() + args.putInt(POSITION, position) + dialog.arguments = args + settingsViewModel.clickedItem = item + return dialog + } + } +} diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsAdapter.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsAdapter.kt index 7c1a9c23cc..d7311eded5 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsAdapter.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsAdapter.kt @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later package org.yuzu.yuzu_emu.features.settings.ui @@ -101,6 +101,11 @@ class SettingsAdapter( SettingsItem.TYPE_PATH -> { PathViewHolder(ListItemSettingBinding.inflate(inflater), this) } + + SettingsItem.TYPE_GPU_UNSWIZZLE -> { + GpuUnswizzleViewHolder(ListItemSettingBinding.inflate(inflater), this) + } + else -> { HeaderViewHolder(ListItemSettingsHeaderBinding.inflate(inflater), this) } @@ -474,6 +479,14 @@ class SettingsAdapter( settingsViewModel.setShouldShowPathResetDialog(true) } + fun onGpuUnswizzleClick(item: GpuUnswizzleSetting, position: Int) { + GpuUnswizzleDialogFragment.newInstance( + settingsViewModel, + item, + position + ).show(fragment.childFragmentManager, GpuUnswizzleDialogFragment.TAG) + } + private class DiffCallback : DiffUtil.ItemCallback() { override fun areItemsTheSame(oldItem: SettingsItem, newItem: SettingsItem): Boolean { return oldItem.setting.key == newItem.setting.key diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt index 8135b6043c..e44c589e67 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt @@ -282,9 +282,7 @@ class SettingsFragmentPresenter( add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key) add(BooleanSetting.FIX_BLOOM_EFFECTS.key) add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key) - add(IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.key) - add(IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.key) - add(IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.key) + add("gpu_unswizzle_combined") add(HeaderSetting(R.string.extensions)) diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/viewholder/GpuUnswizzleViewHolder.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/viewholder/GpuUnswizzleViewHolder.kt new file mode 100644 index 0000000000..06701eb077 --- /dev/null +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/viewholder/GpuUnswizzleViewHolder.kt @@ -0,0 +1,71 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +package org.yuzu.yuzu_emu.features.settings.ui.viewholder + +import android.view.View +import org.yuzu.yuzu_emu.R +import org.yuzu.yuzu_emu.databinding.ListItemSettingBinding +import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting +import org.yuzu.yuzu_emu.features.settings.model.view.SettingsItem +import org.yuzu.yuzu_emu.features.settings.ui.SettingsAdapter +import org.yuzu.yuzu_emu.utils.ViewUtils.setVisible + +class GpuUnswizzleViewHolder(val binding: ListItemSettingBinding, adapter: SettingsAdapter) : + SettingViewHolder(binding.root, adapter) { + private lateinit var setting: GpuUnswizzleSetting + + override fun bind(item: SettingsItem) { + setting = item as GpuUnswizzleSetting + binding.textSettingName.text = setting.title + binding.textSettingDescription.setVisible(item.description.isNotEmpty()) + binding.textSettingDescription.text = item.description + + binding.textSettingValue.setVisible(true) + val resMgr = binding.root.context.resources + + if (setting.isEnabled()) { + // Show a summary of current settings + val textureSizeEntries = resMgr.getStringArray(setting.textureSizeChoicesId) + val textureSizeValues = resMgr.getIntArray(setting.textureSizeValuesId) + val textureSizeIndex = textureSizeValues.indexOf(setting.getTextureSize()) + val textureSizeLabel = if (textureSizeIndex >= 0) textureSizeEntries[textureSizeIndex] else "?" + + val streamSizeEntries = resMgr.getStringArray(setting.streamSizeChoicesId) + val streamSizeValues = resMgr.getIntArray(setting.streamSizeValuesId) + val streamSizeIndex = streamSizeValues.indexOf(setting.getStreamSize()) + val streamSizeLabel = if (streamSizeIndex >= 0) streamSizeEntries[streamSizeIndex] else "?" + + val chunkSizeEntries = resMgr.getStringArray(setting.chunkSizeChoicesId) + val chunkSizeValues = resMgr.getIntArray(setting.chunkSizeValuesId) + val chunkSizeIndex = chunkSizeValues.indexOf(setting.getChunkSize()) + val chunkSizeLabel = if (chunkSizeIndex >= 0) chunkSizeEntries[chunkSizeIndex] else "?" + + binding.textSettingValue.text = "$textureSizeLabel ⋅ $streamSizeLabel ⋅ $chunkSizeLabel" + } else { + binding.textSettingValue.text = resMgr.getString(R.string.gpu_unswizzle_disabled) + } + + binding.buttonClear.setVisible(setting.clearable) + binding.buttonClear.setOnClickListener { + adapter.onClearClick(setting, bindingAdapterPosition) + } + + setStyle(setting.isEditable, binding) + } + + override fun onClick(clicked: View) { + if (!setting.isEditable) { + return + } + + adapter.onGpuUnswizzleClick(setting, bindingAdapterPosition) + } + + override fun onLongClick(clicked: View): Boolean { + if (setting.isEditable) { + return adapter.onLongClick(setting, bindingAdapterPosition) + } + return false + } +} diff --git a/src/android/app/src/main/res/layout/dialog_gpu_unswizzle.xml b/src/android/app/src/main/res/layout/dialog_gpu_unswizzle.xml new file mode 100644 index 0000000000..8299551618 --- /dev/null +++ b/src/android/app/src/main/res/layout/dialog_gpu_unswizzle.xml @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/android/app/src/main/res/values/strings.xml b/src/android/app/src/main/res/values/strings.xml index 97aa054e8a..531b14789c 100644 --- a/src/android/app/src/main/res/values/strings.xml +++ b/src/android/app/src/main/res/values/strings.xml @@ -504,12 +504,17 @@ Reduces bloom blur in LA/EOW (Adreno 700), removes bloom in Burnout Use asynchronous shaders Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches. + GPU Unswizzle Settings + Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality. + Enable GPU Unswizzle + Disabled GPU Unswizzle Max Texture Size Sets the maximum size (MB) for GPU-based texture unswizzling. While the GPU is faster for medium and large textures, the CPU may be more efficient for very small ones. Adjust this to find the balance between GPU acceleration and CPU overhead. GPU Unswizzle Stream Size Sets the data limit per frame for unswizzling large textures. Higher values speed up texture loading at the cost of higher frame latency; lower values reduce GPU overhead but may cause visible texture pop-in. GPU Unswizzle Chunk Size Defines the number of depth slices processed per batch for 3D textures. Increasing this improves throughput efficiency on powerful GPUs but may cause stuttering or driver timeouts on weaker hardware. + Default Extensions diff --git a/src/common/settings.h b/src/common/settings.h index a609894027..770acdbb69 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -532,6 +532,9 @@ struct Values { Category::RendererHacks, Specialization::Default}; + SwitchableSetting gpu_unswizzle_enabled{linkage, false, "gpu_unswizzle_enabled", + Category::RendererHacks}; + SwitchableSetting dyna_state{linkage, #if defined (_WIN32) ExtendedDynamicState::EDS3,