mirror/pineapple
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

early-access version 1489

Browse source
This commit is contained in:
pineappleEA 2021-02-28 05:08:39 +01:00
parent 2073701e78
commit 70ed6ce99a
42 changed files with 554 additions and 493 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 1487. This is the source code for early-access 1489.
## Legal Notice ## Legal Notice

1
src/common/cityhash.h
View file

@ -61,6 +61,7 @@
#pragma once #pragma once
#include <cstddef>
#include "common/common_types.h" #include "common/common_types.h"
namespace Common { namespace Common {

14
src/common/fiber.cpp
View file

@ -24,7 +24,7 @@ struct Fiber::FiberImpl {
std::function<void(void*)> rewind_point; std::function<void(void*)> rewind_point;
void* rewind_parameter{}; void* rewind_parameter{};
void* start_parameter{}; void* start_parameter{};
std::shared_ptr<Fiber> previous_fiber; Fiber* previous_fiber;
bool is_thread_fiber{}; bool is_thread_fiber{};
bool released{}; bool released{};
@ -47,7 +47,7 @@ void Fiber::Start(boost::context::detail::transfer_t& transfer) {
ASSERT(impl->previous_fiber != nullptr); ASSERT(impl->previous_fiber != nullptr);
impl->previous_fiber->impl->context = transfer.fctx; impl->previous_fiber->impl->context = transfer.fctx;
impl->previous_fiber->impl->guard.unlock(); impl->previous_fiber->impl->guard.unlock();
impl->previous_fiber.reset(); impl->previous_fiber = nullptr;
impl->entry_point(impl->start_parameter); impl->entry_point(impl->start_parameter);
UNREACHABLE(); UNREACHABLE();
} }
@ -116,20 +116,20 @@ void Fiber::Rewind() {
boost::context::detail::jump_fcontext(impl->rewind_context, this); boost::context::detail::jump_fcontext(impl->rewind_context, this);
} }
void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) { void Fiber::YieldTo(Fiber* from, Fiber* to) {
ASSERT_MSG(from != nullptr, "Yielding fiber is null!"); ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
ASSERT_MSG(to != nullptr, "Next fiber is null!"); ASSERT_MSG(to != nullptr, "Next fiber is null!");
to->impl->guard.lock(); to->impl->guard.lock();
to->impl->previous_fiber = from; to->impl->previous_fiber = from;
auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get()); auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to);
ASSERT(from->impl->previous_fiber != nullptr); ASSERT(from->impl->previous_fiber != nullptr);
from->impl->previous_fiber->impl->context = transfer.fctx; from->impl->previous_fiber->impl->context = transfer.fctx;
from->impl->previous_fiber->impl->guard.unlock(); from->impl->previous_fiber->impl->guard.unlock();
from->impl->previous_fiber.reset(); from->impl->previous_fiber = nullptr;
} }
std::shared_ptr<Fiber> Fiber::ThreadToFiber() { std::unique_ptr<Fiber> Fiber::ThreadToFiber() {
std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()}; std::unique_ptr<Fiber> fiber = std::unique_ptr<Fiber>{new Fiber()};
fiber->impl->guard.lock(); fiber->impl->guard.lock();
fiber->impl->is_thread_fiber = true; fiber->impl->is_thread_fiber = true;
return fiber; return fiber;

4
src/common/fiber.h
View file

@ -41,8 +41,8 @@ public:
/// Yields control from Fiber 'from' to Fiber 'to' /// Yields control from Fiber 'from' to Fiber 'to'
/// Fiber 'from' must be the currently running fiber. /// Fiber 'from' must be the currently running fiber.
static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to); static void YieldTo(Fiber* from, Fiber* to);
[[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber(); [[nodiscard]] static std::unique_ptr<Fiber> ThreadToFiber();
void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param); void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);

11
src/core/cpu_manager.cpp
View file

@ -111,7 +111,7 @@ void CpuManager::MultiCoreRunGuestThread() {
auto& kernel = system.Kernel(); auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart(); kernel.CurrentScheduler()->OnThreadStart();
auto* thread = kernel.CurrentScheduler()->GetCurrentThread(); auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
auto& host_context = thread->GetHostContext(); auto host_context = thread->GetHostContext();
host_context->SetRewindPoint(GuestRewindFunction, this); host_context->SetRewindPoint(GuestRewindFunction, this);
MultiCoreRunGuestLoop(); MultiCoreRunGuestLoop();
} }
@ -148,7 +148,8 @@ void CpuManager::MultiCoreRunSuspendThread() {
auto core = kernel.GetCurrentHostThreadID(); auto core = kernel.GetCurrentHostThreadID();
auto& scheduler = *kernel.CurrentScheduler(); auto& scheduler = *kernel.CurrentScheduler();
Kernel::KThread* current_thread = scheduler.GetCurrentThread(); Kernel::KThread* current_thread = scheduler.GetCurrentThread();
Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[core].host_context); Common::Fiber::YieldTo(current_thread->GetHostContext(),
core_data[core].host_context.get());
ASSERT(scheduler.ContextSwitchPending()); ASSERT(scheduler.ContextSwitchPending());
ASSERT(core == kernel.GetCurrentHostThreadID()); ASSERT(core == kernel.GetCurrentHostThreadID());
scheduler.RescheduleCurrentCore(); scheduler.RescheduleCurrentCore();
@ -201,7 +202,7 @@ void CpuManager::SingleCoreRunGuestThread() {
auto& kernel = system.Kernel(); auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart(); kernel.CurrentScheduler()->OnThreadStart();
auto* thread = kernel.CurrentScheduler()->GetCurrentThread(); auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
auto& host_context = thread->GetHostContext(); auto host_context = thread->GetHostContext();
host_context->SetRewindPoint(GuestRewindFunction, this); host_context->SetRewindPoint(GuestRewindFunction, this);
SingleCoreRunGuestLoop(); SingleCoreRunGuestLoop();
} }
@ -245,7 +246,7 @@ void CpuManager::SingleCoreRunSuspendThread() {
auto core = kernel.GetCurrentHostThreadID(); auto core = kernel.GetCurrentHostThreadID();
auto& scheduler = *kernel.CurrentScheduler(); auto& scheduler = *kernel.CurrentScheduler();
Kernel::KThread* current_thread = scheduler.GetCurrentThread(); Kernel::KThread* current_thread = scheduler.GetCurrentThread();
Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context); Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context.get());
ASSERT(scheduler.ContextSwitchPending()); ASSERT(scheduler.ContextSwitchPending());
ASSERT(core == kernel.GetCurrentHostThreadID()); ASSERT(core == kernel.GetCurrentHostThreadID());
scheduler.RescheduleCurrentCore(); scheduler.RescheduleCurrentCore();
@ -363,7 +364,7 @@ void CpuManager::RunThread(std::size_t core) {
auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread(); auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
data.is_running = true; data.is_running = true;
Common::Fiber::YieldTo(data.host_context, current_thread->GetHostContext()); Common::Fiber::YieldTo(data.host_context.get(), current_thread->GetHostContext());
data.is_running = false; data.is_running = false;
data.is_paused = true; data.is_paused = true;
data.exit_barrier->Wait(); data.exit_barrier->Wait();

2
src/core/cpu_manager.h
View file

@ -83,7 +83,7 @@ private:
void RunThread(std::size_t core); void RunThread(std::size_t core);
struct CoreData { struct CoreData {
std::shared_ptr<Common::Fiber> host_context; std::unique_ptr<Common::Fiber> host_context;
std::unique_ptr<Common::Event> enter_barrier; std::unique_ptr<Common::Event> enter_barrier;
std::unique_ptr<Common::Event> exit_barrier; std::unique_ptr<Common::Event> exit_barrier;
std::atomic<bool> is_running; std::atomic<bool> is_running;

18
src/core/hle/kernel/k_scheduler.cpp
View file

@ -608,7 +608,7 @@ void KScheduler::YieldToAnyThread(KernelCore& kernel) {
} }
KScheduler::KScheduler(Core::System& system, s32 core_id) : system(system), core_id(core_id) { KScheduler::KScheduler(Core::System& system, s32 core_id) : system(system), core_id(core_id) {
switch_fiber = std::make_shared<Common::Fiber>(OnSwitch, this); switch_fiber = std::make_unique<Common::Fiber>(OnSwitch, this);
state.needs_scheduling.store(true); state.needs_scheduling.store(true);
state.interrupt_task_thread_runnable = false; state.interrupt_task_thread_runnable = false;
state.should_count_idle = false; state.should_count_idle = false;
@ -726,15 +726,15 @@ void KScheduler::ScheduleImpl() {
// Save context for previous thread // Save context for previous thread
Unload(previous_thread); Unload(previous_thread);
std::shared_ptr<Common::Fiber>* old_context; Common::Fiber* old_context;
if (previous_thread != nullptr) { if (previous_thread != nullptr) {
old_context = &previous_thread->GetHostContext(); old_context = previous_thread->GetHostContext();
} else { } else {
old_context = &idle_thread->GetHostContext(); old_context = idle_thread->GetHostContext();
} }
guard.unlock(); guard.unlock();
Common::Fiber::YieldTo(*old_context, switch_fiber); Common::Fiber::YieldTo(old_context, switch_fiber.get());
/// When a thread wakes up, the scheduler may have changed to other in another core. /// When a thread wakes up, the scheduler may have changed to other in another core.
auto& next_scheduler = *system.Kernel().CurrentScheduler(); auto& next_scheduler = *system.Kernel().CurrentScheduler();
next_scheduler.SwitchContextStep2(); next_scheduler.SwitchContextStep2();
@ -769,13 +769,13 @@ void KScheduler::SwitchToCurrent() {
break; break;
} }
} }
std::shared_ptr<Common::Fiber>* next_context; Common::Fiber* next_context;
if (next_thread != nullptr) { if (next_thread != nullptr) {
next_context = &next_thread->GetHostContext(); next_context = next_thread->GetHostContext();
} else { } else {
next_context = &idle_thread->GetHostContext(); next_context = idle_thread->GetHostContext();
} }
Common::Fiber::YieldTo(switch_fiber, *next_context); Common::Fiber::YieldTo(switch_fiber.get(), next_context);
} while (!is_switch_pending()); } while (!is_switch_pending());
} }
} }

10
src/core/hle/kernel/k_scheduler.h
View file

@ -68,12 +68,12 @@ public:
void OnThreadStart(); void OnThreadStart();
[[nodiscard]] std::shared_ptr<Common::Fiber>& ControlContext() { [[nodiscard]] Common::Fiber* ControlContext() {
return switch_fiber; return switch_fiber.get();
} }
[[nodiscard]] const std::shared_ptr<Common::Fiber>& ControlContext() const { [[nodiscard]] const Common::Fiber* ControlContext() const {
return switch_fiber; return switch_fiber.get();
} }
[[nodiscard]] u64 UpdateHighestPriorityThread(KThread* highest_thread); [[nodiscard]] u64 UpdateHighestPriorityThread(KThread* highest_thread);
@ -178,7 +178,7 @@ private:
KThread* idle_thread; KThread* idle_thread;
std::shared_ptr<Common::Fiber> switch_fiber{}; std::unique_ptr<Common::Fiber> switch_fiber{};
struct SchedulingState { struct SchedulingState {
std::atomic<bool> needs_scheduling; std::atomic<bool> needs_scheduling;

6
src/core/hle/kernel/k_thread.cpp
View file

@ -991,10 +991,6 @@ void KThread::SetState(ThreadState state) {
} }
} }
std::shared_ptr<Common::Fiber>& KThread::GetHostContext() {
return host_context;
}
ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, ThreadType type_flags, ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, ThreadType type_flags,
std::string name, VAddr entry_point, std::string name, VAddr entry_point,
u32 priority, u64 arg, s32 processor_id, u32 priority, u64 arg, s32 processor_id,
@ -1028,7 +1024,7 @@ ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, Thread
scheduler.AddThread(thread); scheduler.AddThread(thread);
thread->host_context = thread->host_context =
std::make_shared<Common::Fiber>(std::move(thread_start_func), thread_start_parameter); std::make_unique<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);
return MakeResult<std::shared_ptr<KThread>>(std::move(thread)); return MakeResult<std::shared_ptr<KThread>>(std::move(thread));
} }

10
src/core/hle/kernel/k_thread.h
View file

@ -293,7 +293,13 @@ public:
return thread_context_64; return thread_context_64;
} }
[[nodiscard]] std::shared_ptr<Common::Fiber>& GetHostContext(); [[nodiscard]] Common::Fiber* GetHostContext() {
return host_context.get();
}
[[nodiscard]] const Common::Fiber* GetHostContext() const {
return host_context.get();
}
[[nodiscard]] ThreadState GetState() const { [[nodiscard]] ThreadState GetState() const {
return thread_state & ThreadState::Mask; return thread_state & ThreadState::Mask;
@ -719,7 +725,7 @@ private:
Common::SpinLock context_guard{}; Common::SpinLock context_guard{};
// For emulation // For emulation
std::shared_ptr<Common::Fiber> host_context{}; std::unique_ptr<Common::Fiber> host_context{};
// For debugging // For debugging
std::vector<KSynchronizationObject*> wait_objects_for_debugging; std::vector<KSynchronizationObject*> wait_objects_for_debugging;

3
src/core/hle/kernel/svc.cpp
View file

@ -2626,8 +2626,7 @@ void Call(Core::System& system, u32 immediate) {
kernel.ExitSVCProfile(); kernel.ExitSVCProfile();
if (!thread->IsCallingSvc()) { if (!thread->IsCallingSvc()) {
auto* host_context = thread->GetHostContext().get(); thread->GetHostContext()->Rewind();
host_context->Rewind();
} }
system.EnterDynarmicProfile(); system.EnterDynarmicProfile();

8
src/core/hle/service/hid/controllers/gesture.h
View file

@ -116,10 +116,10 @@ private:
// Returns an unused finger id, if there is no fingers avaliable MAX_FINGERS will be returned // Returns an unused finger id, if there is no fingers avaliable MAX_FINGERS will be returned
std::optional<size_t> GetUnusedFingerID() const; std::optional<size_t> GetUnusedFingerID() const;
// If the touch is new it tries to assing a new finger id, if there is no fingers avaliable no /** If the touch is new it tries to assing a new finger id, if there is no fingers avaliable no
// changes will be made. Updates the coordinates if the finger id it's already set. If the touch * changes will be made. Updates the coordinates if the finger id it's already set. If the touch
// ends delays the output by one frame to set the end_touch flag before finally freeing the * ends delays the output by one frame to set the end_touch flag before finally freeing the
// finger id * finger id */
size_t UpdateTouchInputEvent(const std::tuple<float, float, bool>& touch_input, size_t UpdateTouchInputEvent(const std::tuple<float, float, bool>& touch_input,
size_t finger_id); size_t finger_id);

2
src/core/hle/service/ldn/ldn.cpp
View file

@ -156,7 +156,7 @@ public:
is_initialized = true; is_initialized = true;
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(RESULT_SUCCESS); rb.Push(ERROR_DISABLED);
} }
private: private:

11
src/input_common/mouse/mouse_input.cpp
View file

@ -59,7 +59,7 @@ void Mouse::UpdateYuzuSettings() {
}); });
} }
void Mouse::PressButton(int x, int y, int button_) { void Mouse::PressButton(int x, int y, MouseButton button_) {
const auto button_index = static_cast<std::size_t>(button_); const auto button_index = static_cast<std::size_t>(button_);
if (button_index >= mouse_info.size()) { if (button_index >= mouse_info.size()) {
return; return;
@ -67,7 +67,7 @@ void Mouse::PressButton(int x, int y, int button_) {
const auto button = 1U << button_index; const auto button = 1U << button_index;
buttons |= static_cast<u16>(button); buttons |= static_cast<u16>(button);
last_button = static_cast<MouseButton>(button_index); last_button = button_;
mouse_info[button_index].mouse_origin = Common::MakeVec(x, y); mouse_info[button_index].mouse_origin = Common::MakeVec(x, y);
mouse_info[button_index].last_mouse_position = Common::MakeVec(x, y); mouse_info[button_index].last_mouse_position = Common::MakeVec(x, y);
@ -129,7 +129,7 @@ void Mouse::MouseMove(int x, int y, int center_x, int center_y) {
} }
} }
void Mouse::ReleaseButton(int button_) { void Mouse::ReleaseButton(MouseButton button_) {
const auto button_index = static_cast<std::size_t>(button_); const auto button_index = static_cast<std::size_t>(button_);
if (button_index >= mouse_info.size()) { if (button_index >= mouse_info.size()) {
return; return;
@ -152,6 +152,11 @@ void Mouse::BeginConfiguration() {
void Mouse::EndConfiguration() { void Mouse::EndConfiguration() {
buttons = 0; buttons = 0;
for (MouseInfo& info : mouse_info) {
info.tilt_speed = 0;
info.data.pressed = false;
info.data.axis = {0, 0};
}
last_button = MouseButton::Undefined; last_button = MouseButton::Undefined;
mouse_queue.Clear(); mouse_queue.Clear();
configuring = false; configuring = false;

12
src/input_common/mouse/mouse_input.h
View file

@ -18,10 +18,12 @@ namespace MouseInput {
enum class MouseButton { enum class MouseButton {
Left, Left,
Wheel,
Right, Right,
Forward, Wheel,
Backward, Backward,
Forward,
Task,
Extra,
Undefined, Undefined,
}; };
@ -51,7 +53,7 @@ public:
* @param y the y-coordinate of the cursor * @param y the y-coordinate of the cursor
* @param button_ the button pressed * @param button_ the button pressed
*/ */
void PressButton(int x, int y, int button_); void PressButton(int x, int y, MouseButton button_);
/** /**
* Signals that mouse has moved. * Signals that mouse has moved.
@ -65,7 +67,7 @@ public:
/** /**
* Signals that a motion sensor tilt has ended. * Signals that a motion sensor tilt has ended.
*/ */
void ReleaseButton(int button_); void ReleaseButton(MouseButton button_);
[[nodiscard]] Common::SPSCQueue<MouseStatus>& GetMouseQueue(); [[nodiscard]] Common::SPSCQueue<MouseStatus>& GetMouseQueue();
[[nodiscard]] const Common::SPSCQueue<MouseStatus>& GetMouseQueue() const; [[nodiscard]] const Common::SPSCQueue<MouseStatus>& GetMouseQueue() const;
@ -94,7 +96,7 @@ private:
u16 buttons{}; u16 buttons{};
std::thread update_thread; std::thread update_thread;
MouseButton last_button{MouseButton::Undefined}; MouseButton last_button{MouseButton::Undefined};
std::array<MouseInfo, 5> mouse_info; std::array<MouseInfo, 7> mouse_info;
Common::SPSCQueue<MouseStatus> mouse_queue; Common::SPSCQueue<MouseStatus> mouse_queue;
bool configuring{false}; bool configuring{false};
bool update_thread_running{true}; bool update_thread_running{true};

39
src/tests/common/fibers.cpp
View file

@ -67,16 +67,15 @@ void TestControl1::DoWork() {
value++; value++;
} }
results[id] = value; results[id] = value;
Fiber::YieldTo(work_fibers[id], thread_fibers[id]); Fiber::YieldTo(work_fibers[id].get(), thread_fibers[id].get());
} }
void TestControl1::ExecuteThread(u32 id) { void TestControl1::ExecuteThread(u32 id) {
thread_ids.Register(id); thread_ids.Register(id);
auto thread_fiber = Fiber::ThreadToFiber(); thread_fibers[id] = Fiber::ThreadToFiber();
thread_fibers[id] = thread_fiber;
work_fibers[id] = std::make_shared<Fiber>(std::function<void(void*)>{WorkControl1}, this); work_fibers[id] = std::make_shared<Fiber>(std::function<void(void*)>{WorkControl1}, this);
items[id] = rand() % 256; items[id] = rand() % 256;
Fiber::YieldTo(thread_fibers[id], work_fibers[id]); Fiber::YieldTo(thread_fibers[id].get(), work_fibers[id].get());
thread_fibers[id]->Exit(); thread_fibers[id]->Exit();
} }
@ -117,11 +116,11 @@ public:
for (u32 i = 0; i < 12000; i++) { for (u32 i = 0; i < 12000; i++) {
value1 += i; value1 += i;
} }
Fiber::YieldTo(fiber1, fiber3); Fiber::YieldTo(fiber1.get(), fiber3.get());
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
assert1 = id == 1; assert1 = id == 1;
value2 += 5000; value2 += 5000;
Fiber::YieldTo(fiber1, thread_fibers[id]); Fiber::YieldTo(fiber1.get(), thread_fibers[id].get());
} }
void DoWork2() { void DoWork2() {
@ -129,7 +128,7 @@ public:
; ;
value2 = 2000; value2 = 2000;
trap = false; trap = false;
Fiber::YieldTo(fiber2, fiber1); Fiber::YieldTo(fiber2.get(), fiber1.get());
assert3 = false; assert3 = false;
} }
@ -137,19 +136,19 @@ public:
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
assert2 = id == 0; assert2 = id == 0;
value1 += 1000; value1 += 1000;
Fiber::YieldTo(fiber3, thread_fibers[id]); Fiber::YieldTo(fiber3.get(), thread_fibers[id].get());
} }
void ExecuteThread(u32 id); void ExecuteThread(u32 id);
void CallFiber1() { void CallFiber1() {
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
Fiber::YieldTo(thread_fibers[id], fiber1); Fiber::YieldTo(thread_fibers[id].get(), fiber1.get());
} }
void CallFiber2() { void CallFiber2() {
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
Fiber::YieldTo(thread_fibers[id], fiber2); Fiber::YieldTo(thread_fibers[id].get(), fiber2.get());
} }
void Exit(); void Exit();
@ -185,8 +184,7 @@ static void WorkControl2_3(void* control) {
void TestControl2::ExecuteThread(u32 id) { void TestControl2::ExecuteThread(u32 id) {
thread_ids.Register(id); thread_ids.Register(id);
auto thread_fiber = Fiber::ThreadToFiber(); thread_fibers[id] = Fiber::ThreadToFiber();
thread_fibers[id] = thread_fiber;
} }
void TestControl2::Exit() { void TestControl2::Exit() {
@ -241,23 +239,23 @@ public:
void DoWork1() { void DoWork1() {
value1 += 1; value1 += 1;
Fiber::YieldTo(fiber1, fiber2); Fiber::YieldTo(fiber1.get(), fiber2.get());
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
value3 += 1; value3 += 1;
Fiber::YieldTo(fiber1, thread_fibers[id]); Fiber::YieldTo(fiber1.get(), thread_fibers[id].get());
} }
void DoWork2() { void DoWork2() {
value2 += 1; value2 += 1;
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
Fiber::YieldTo(fiber2, thread_fibers[id]); Fiber::YieldTo(fiber2.get(), thread_fibers[id].get());
} }
void ExecuteThread(u32 id); void ExecuteThread(u32 id);
void CallFiber1() { void CallFiber1() {
const u32 id = thread_ids.Get(); const u32 id = thread_ids.Get();
Fiber::YieldTo(thread_fibers[id], fiber1); Fiber::YieldTo(thread_fibers[id].get(), fiber1.get());
} }
void Exit(); void Exit();
@ -266,7 +264,7 @@ public:
u32 value2{}; u32 value2{};
u32 value3{}; u32 value3{};
ThreadIds thread_ids; ThreadIds thread_ids;
std::vector<std::shared_ptr<Common::Fiber>> thread_fibers; std::vector<std::unique_ptr<Common::Fiber>> thread_fibers;
std::shared_ptr<Common::Fiber> fiber1; std::shared_ptr<Common::Fiber> fiber1;
std::shared_ptr<Common::Fiber> fiber2; std::shared_ptr<Common::Fiber> fiber2;
}; };
@ -283,8 +281,7 @@ static void WorkControl3_2(void* control) {
void TestControl3::ExecuteThread(u32 id) { void TestControl3::ExecuteThread(u32 id) {
thread_ids.Register(id); thread_ids.Register(id);
auto thread_fiber = Fiber::ThreadToFiber(); thread_fibers[id] = Fiber::ThreadToFiber();
thread_fibers[id] = thread_fiber;
} }
void TestControl3::Exit() { void TestControl3::Exit() {
@ -332,7 +329,7 @@ public:
void Execute() { void Execute() {
thread_fiber = Fiber::ThreadToFiber(); thread_fiber = Fiber::ThreadToFiber();
Fiber::YieldTo(thread_fiber, fiber1); Fiber::YieldTo(thread_fiber.get(), fiber1.get());
thread_fiber->Exit(); thread_fiber->Exit();
} }
@ -340,7 +337,7 @@ public:
fiber1->SetRewindPoint(std::function<void(void*)>{WorkControl4}, this); fiber1->SetRewindPoint(std::function<void(void*)>{WorkControl4}, this);
if (rewinded) { if (rewinded) {
goal_reached = true; goal_reached = true;
Fiber::YieldTo(fiber1, thread_fiber); Fiber::YieldTo(fiber1.get(), thread_fiber.get());
} }
rewinded = true; rewinded = true;
fiber1->Rewind(); fiber1->Rewind();

54
src/video_core/compatible_formats.cpp
View file

@ -39,6 +39,16 @@ constexpr std::array VIEW_CLASS_64_BITS{
// TODO: How should we handle 48 bits? // TODO: How should we handle 48 bits?
constexpr std::array VIEW_CLASS_32_BITS{ constexpr std::array VIEW_CLASS_32_BITS{
PixelFormat::R16G16_FLOAT, PixelFormat::B10G11R11_FLOAT, PixelFormat::R32_FLOAT,
PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT, PixelFormat::R32_UINT,
PixelFormat::R16G16_SINT, PixelFormat::R32_SINT, PixelFormat::A8B8G8R8_UNORM,
PixelFormat::R16G16_UNORM, PixelFormat::A8B8G8R8_SNORM, PixelFormat::R16G16_SNORM,
PixelFormat::A8B8G8R8_SRGB, PixelFormat::E5B9G9R9_FLOAT, PixelFormat::B8G8R8A8_UNORM,
PixelFormat::B8G8R8A8_SRGB, PixelFormat::A8B8G8R8_UINT, PixelFormat::A8B8G8R8_SINT,
PixelFormat::A2B10G10R10_UINT,
};
constexpr std::array VIEW_CLASS_32_BITS_NO_BGR{
PixelFormat::R16G16_FLOAT, PixelFormat::B10G11R11_FLOAT, PixelFormat::R32_FLOAT, PixelFormat::R16G16_FLOAT, PixelFormat::B10G11R11_FLOAT, PixelFormat::R32_FLOAT,
PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT, PixelFormat::R32_UINT, PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT, PixelFormat::R32_UINT,
PixelFormat::R16G16_SINT, PixelFormat::R32_SINT, PixelFormat::A8B8G8R8_UNORM, PixelFormat::R16G16_SINT, PixelFormat::R32_SINT, PixelFormat::A8B8G8R8_UNORM,
@ -204,7 +214,6 @@ constexpr Table MakeViewTable() {
EnableRange(view, VIEW_CLASS_128_BITS); EnableRange(view, VIEW_CLASS_128_BITS);
EnableRange(view, VIEW_CLASS_96_BITS); EnableRange(view, VIEW_CLASS_96_BITS);
EnableRange(view, VIEW_CLASS_64_BITS); EnableRange(view, VIEW_CLASS_64_BITS);
EnableRange(view, VIEW_CLASS_32_BITS);
EnableRange(view, VIEW_CLASS_16_BITS); EnableRange(view, VIEW_CLASS_16_BITS);
EnableRange(view, VIEW_CLASS_8_BITS); EnableRange(view, VIEW_CLASS_8_BITS);
EnableRange(view, VIEW_CLASS_RGTC1_RED); EnableRange(view, VIEW_CLASS_RGTC1_RED);
@ -230,20 +239,55 @@ constexpr Table MakeCopyTable() {
EnableRange(copy, COPY_CLASS_64_BITS); EnableRange(copy, COPY_CLASS_64_BITS);
return copy; return copy;
} }
constexpr Table MakeNativeBgrViewTable() {
Table copy = MakeViewTable();
EnableRange(copy, VIEW_CLASS_32_BITS);
return copy;
}
constexpr Table MakeNonNativeBgrViewTable() {
Table copy = MakeViewTable();
EnableRange(copy, VIEW_CLASS_32_BITS_NO_BGR);
return copy;
}
constexpr Table MakeNativeBgrCopyTable() {
Table copy = MakeCopyTable();
EnableRange(copy, VIEW_CLASS_32_BITS);
return copy;
}
constexpr Table MakeNonNativeBgrCopyTable() {
Table copy = MakeCopyTable();
EnableRange(copy, VIEW_CLASS_32_BITS);
return copy;
}
} // Anonymous namespace } // Anonymous namespace
bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views) { bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views,
bool native_bgr) {
if (broken_views) { if (broken_views) {
// If format views are broken, only accept formats that are identical. // If format views are broken, only accept formats that are identical.
return format_a == format_b; return format_a == format_b;
} }
static constexpr Table TABLE = MakeViewTable(); if (native_bgr) {
static constexpr Table TABLE = MakeNativeBgrViewTable();
return IsSupported(TABLE, format_a, format_b);
} else {
static constexpr Table TABLE = MakeNonNativeBgrViewTable();
return IsSupported(TABLE, format_a, format_b); return IsSupported(TABLE, format_a, format_b);
} }
}
bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b) { bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b, bool native_bgr) {
static constexpr Table TABLE = MakeCopyTable(); if (native_bgr) {
static constexpr Table TABLE = MakeNativeBgrCopyTable();
return IsSupported(TABLE, format_a, format_b); return IsSupported(TABLE, format_a, format_b);
} else {
static constexpr Table TABLE = MakeNonNativeBgrCopyTable();
return IsSupported(TABLE, format_a, format_b);
}
} }
} // namespace VideoCore::Surface } // namespace VideoCore::Surface

5
src/video_core/compatible_formats.h
View file

@ -8,8 +8,9 @@
namespace VideoCore::Surface { namespace VideoCore::Surface {
bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views); bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views,
bool native_bgr);
bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b); bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b, bool native_bgr);
} // namespace VideoCore::Surface } // namespace VideoCore::Surface

1
src/video_core/host_shaders/CMakeLists.txt
View file

@ -6,7 +6,6 @@ set(SHADER_FILES
convert_float_to_depth.frag convert_float_to_depth.frag
full_screen_triangle.vert full_screen_triangle.vert
opengl_copy_bc4.comp opengl_copy_bc4.comp
opengl_copy_bgr16.comp
opengl_copy_bgra.comp opengl_copy_bgra.comp
opengl_present.frag opengl_present.frag
opengl_present.vert opengl_present.vert

449
src/video_core/host_shaders/astc_decoder.comp
View file

@ -48,15 +48,6 @@ UNIFORM(6) uint block_height;
UNIFORM(7) uint block_height_mask; UNIFORM(7) uint block_height_mask;
END_PUSH_CONSTANTS END_PUSH_CONSTANTS
uint current_index = 0;
int bitsread = 0;
uint total_bitsread = 0;
uint local_buff[16];
const int JustBits = 0;
const int Quint = 1;
const int Trit = 2;
struct EncodingData { struct EncodingData {
uint encoding; uint encoding;
uint num_bits; uint num_bits;
@ -66,11 +57,11 @@ struct EncodingData {
struct TexelWeightParams { struct TexelWeightParams {
uvec2 size; uvec2 size;
bool dual_plane;
uint max_weight; uint max_weight;
bool Error; bool dual_plane;
bool VoidExtentLDR; bool error_state;
bool VoidExtentHDR; bool void_extent_ldr;
bool void_extent_hdr;
}; };
// Swizzle data // Swizzle data
@ -114,6 +105,72 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1); const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
const int BLOCK_SIZE_IN_BYTES = 16;
const int BLOCK_INFO_ERROR = 0;
const int BLOCK_INFO_VOID_EXTENT_HDR = 1;
const int BLOCK_INFO_VOID_EXTENT_LDR = 2;
const int BLOCK_INFO_NORMAL = 3;
const int JUST_BITS = 0;
const int QUINT = 1;
const int TRIT = 2;
// The following constants are expanded variants of the Replicate()
// function calls corresponding to the following arguments:
// value: index into the generated table
// num_bits: the after "REPLICATE" in the table name. i.e. 4 is num_bits in REPLICATE_4.
// to_bit: the integer after "TO_"
const uint REPLICATE_BIT_TO_7_TABLE[2] = uint[](0, 127);
const uint REPLICATE_1_BIT_TO_9_TABLE[2] = uint[](0, 511);
const uint REPLICATE_1_BIT_TO_8_TABLE[2] = uint[](0, 255);
const uint REPLICATE_2_BIT_TO_8_TABLE[4] = uint[](0, 85, 170, 255);
const uint REPLICATE_3_BIT_TO_8_TABLE[8] = uint[](0, 36, 73, 109, 146, 182, 219, 255);
const uint REPLICATE_4_BIT_TO_8_TABLE[16] =
uint[](0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255);
const uint REPLICATE_5_BIT_TO_8_TABLE[32] =
uint[](0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165,
173, 181, 189, 198, 206, 214, 222, 231, 239, 247, 255);
const uint REPLICATE_1_BIT_TO_6_TABLE[2] = uint[](0, 63);
const uint REPLICATE_2_BIT_TO_6_TABLE[4] = uint[](0, 21, 42, 63);
const uint REPLICATE_3_BIT_TO_6_TABLE[8] = uint[](0, 9, 18, 27, 36, 45, 54, 63);
const uint REPLICATE_4_BIT_TO_6_TABLE[16] =
uint[](0, 4, 8, 12, 17, 21, 25, 29, 34, 38, 42, 46, 51, 55, 59, 63);
const uint REPLICATE_5_BIT_TO_6_TABLE[32] =
uint[](0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 33, 35, 37, 39, 41, 43, 45,
47, 49, 51, 53, 55, 57, 59, 61, 63);
// Input ASTC texture globals
uint current_index = 0;
int bitsread = 0;
uint total_bitsread = 0;
uint local_buff[16];
// Color data globals
uint color_endpoint_data[16];
int color_bitsread = 0;
uint total_color_bitsread = 0;
int color_index = 0;
int colvals_index = 0;
// Weight data globals
uint texel_weight_data[16];
int texel_bitsread = 0;
uint total_texel_bitsread = 0;
int texel_index = 0;
bool texel_flag = false;
// Global "vectors" to be pushed into when decoding
EncodingData result_vector[100];
int result_index = 0;
EncodingData texel_vector[100];
int texel_vector_index = 0;
uint unquantized_texel_weights[2][144];
uint SwizzleOffset(uvec2 pos) { uint SwizzleOffset(uvec2 pos) {
pos = pos & SWIZZLE_MASK; pos = pos & SWIZZLE_MASK;
return swizzle_table[pos.y * 64 + pos.x]; return swizzle_table[pos.y * 64 + pos.x];
@ -124,21 +181,10 @@ uint ReadTexel(uint offset) {
return bitfieldExtract(astc_data[offset / 4], int((offset * 8) & 24), 8); return bitfieldExtract(astc_data[offset / 4], int((offset * 8) & 24), 8);
} }
// Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)]
const int BLOCK_SIZE_IN_BYTES = 16; // is the same as [(num_bits - 1):0] and repeats all the way down.
const int BLOCK_INFO_ERROR = 0;
const int BLOCK_INFO_VOID_EXTENT_HDR = 1;
const int BLOCK_INFO_VOID_EXTENT_LDR = 2;
const int BLOCK_INFO_NORMAL = 3;
// Replicates low numBits such that [(toBit - 1):(toBit - 1 - fromBit)]
// is the same as [(numBits - 1):0] and repeats all the way down.
uint Replicate(uint val, uint num_bits, uint to_bit) { uint Replicate(uint val, uint num_bits, uint to_bit) {
if (num_bits == 0) { if (num_bits == 0 || to_bit == 0) {
return 0;
}
if (to_bit == 0) {
return 0; return 0;
} }
const uint v = val & uint((1 << num_bits) - 1); const uint v = val & uint((1 << num_bits) - 1);
@ -163,28 +209,14 @@ uvec4 ReplicateByteTo16(uvec4 value) {
REPLICATE_BYTE_TO_16_TABLE[value.z], REPLICATE_BYTE_TO_16_TABLE[value.w]); REPLICATE_BYTE_TO_16_TABLE[value.z], REPLICATE_BYTE_TO_16_TABLE[value.w]);
} }
const uint REPLICATE_BIT_TO_7_TABLE[2] = uint[](0, 127);
uint ReplicateBitTo7(uint value) { uint ReplicateBitTo7(uint value) {
return REPLICATE_BIT_TO_7_TABLE[value]; return REPLICATE_BIT_TO_7_TABLE[value];
;
} }
const uint REPLICATE_1_BIT_TO_9_TABLE[2] = uint[](0, 511);
uint ReplicateBitTo9(uint value) { uint ReplicateBitTo9(uint value) {
return REPLICATE_1_BIT_TO_9_TABLE[value]; return REPLICATE_1_BIT_TO_9_TABLE[value];
} }
const uint REPLICATE_1_BIT_TO_8_TABLE[2] = uint[](0, 255);
const uint REPLICATE_2_BIT_TO_8_TABLE[4] = uint[](0, 85, 170, 255);
const uint REPLICATE_3_BIT_TO_8_TABLE[8] = uint[](0, 36, 73, 109, 146, 182, 219, 255);
const uint REPLICATE_4_BIT_TO_8_TABLE[16] =
uint[](0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255);
const uint REPLICATE_5_BIT_TO_8_TABLE[32] =
uint[](0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165,
173, 181, 189, 198, 206, 214, 222, 231, 239, 247, 255);
uint FastReplicateTo8(uint value, uint num_bits) { uint FastReplicateTo8(uint value, uint num_bits) {
switch (num_bits) { switch (num_bits) {
case 1: case 1:
@ -207,15 +239,6 @@ uint FastReplicateTo8(uint value, uint num_bits) {
return Replicate(value, num_bits, 8); return Replicate(value, num_bits, 8);
} }
const uint REPLICATE_1_BIT_TO_6_TABLE[2] = uint[](0, 63);
const uint REPLICATE_2_BIT_TO_6_TABLE[4] = uint[](0, 21, 42, 63);
const uint REPLICATE_3_BIT_TO_6_TABLE[8] = uint[](0, 9, 18, 27, 36, 45, 54, 63);
const uint REPLICATE_4_BIT_TO_6_TABLE[16] =
uint[](0, 4, 8, 12, 17, 21, 25, 29, 34, 38, 42, 46, 51, 55, 59, 63);
const uint REPLICATE_5_BIT_TO_6_TABLE[32] =
uint[](0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 33, 35, 37, 39, 41, 43, 45,
47, 49, 51, 53, 55, 57, 59, 61, 63);
uint FastReplicateTo6(uint value, uint num_bits) { uint FastReplicateTo6(uint value, uint num_bits) {
switch (num_bits) { switch (num_bits) {
case 1: case 1:
@ -232,23 +255,23 @@ uint FastReplicateTo6(uint value, uint num_bits) {
return Replicate(value, num_bits, 6); return Replicate(value, num_bits, 6);
} }
uint div3_floor(uint v) { uint Div3Floor(uint v) {
return (v * 0x5556) >> 16; return (v * 0x5556) >> 16;
} }
uint div3_ceil(uint v) { uint Div3Ceil(uint v) {
return div3_floor(v + 2); return Div3Floor(v + 2);
} }
uint div5_floor(uint v) { uint Div5Floor(uint v) {
return (v * 0x3334) >> 16; return (v * 0x3334) >> 16;
} }
uint div5_ceil(uint v) { uint Div5Ceil(uint v) {
return div5_floor(v + 4); return Div5Floor(v + 4);
} }
uint hash52(uint p) { uint Hash52(uint p) {
p ^= p >> 15; p ^= p >> 15;
p -= p << 17; p -= p << 17;
p += p << 7; p += p << 7;
@ -263,9 +286,9 @@ uint hash52(uint p) {
} }
uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bool small_block) { uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bool small_block) {
if (1 == partition_count) if (partition_count == 1) {
return 0; return 0;
}
if (small_block) { if (small_block) {
x <<= 1; x <<= 1;
y <<= 1; y <<= 1;
@ -274,7 +297,7 @@ uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bo
seed += (partition_count - 1) * 1024; seed += (partition_count - 1) * 1024;
uint rnum = hash52(uint(seed)); uint rnum = Hash52(uint(seed));
uint seed1 = uint(rnum & 0xF); uint seed1 = uint(rnum & 0xF);
uint seed2 = uint((rnum >> 4) & 0xF); uint seed2 = uint((rnum >> 4) & 0xF);
uint seed3 = uint((rnum >> 8) & 0xF); uint seed3 = uint((rnum >> 8) & 0xF);
@ -334,19 +357,23 @@ uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bo
c &= 0x3F; c &= 0x3F;
d &= 0x3F; d &= 0x3F;
if (partition_count < 4) if (partition_count < 4) {
d = 0; d = 0;
if (partition_count < 3) }
if (partition_count < 3) {
c = 0; c = 0;
}
if (a >= b && a >= c && a >= d) if (a >= b && a >= c && a >= d) {
return 0; return 0;
else if (b >= c && b >= d) } else if (b >= c && b >= d) {
return 1; return 1;
else if (c >= d) } else if (c >= d) {
return 2; return 2;
} else {
return 3; return 3;
} }
}
uint Select2DPartition(uint seed, uint x, uint y, uint partition_count, bool small_block) { uint Select2DPartition(uint seed, uint x, uint y, uint partition_count, bool small_block) {
return SelectPartition(seed, x, y, 0, partition_count, small_block); return SelectPartition(seed, x, y, 0, partition_count, small_block);
@ -357,10 +384,10 @@ uint ReadBit() {
return 0; return 0;
} }
uint bit = bitfieldExtract(local_buff[current_index], bitsread, 1); uint bit = bitfieldExtract(local_buff[current_index], bitsread, 1);
bitsread++; ++bitsread;
total_bitsread++; ++total_bitsread;
if (bitsread == 8) { if (bitsread == 8) {
current_index++; ++current_index;
bitsread = 0; bitsread = 0;
} }
return bit; return bit;
@ -374,36 +401,22 @@ uint StreamBits(uint num_bits) {
return ret; return ret;
} }
// Define color data.
uint color_endpoint_data[16];
int color_bitsread = 0;
uint total_color_bitsread = 0;
int color_index = 0;
// Define color data.
uint texel_weight_data[16];
int texel_bitsread = 0;
uint total_texel_bitsread = 0;
int texel_index = 0;
bool texel_flag = false;
uint ReadColorBit() { uint ReadColorBit() {
uint bit = 0; uint bit = 0;
if (texel_flag) { if (texel_flag) {
bit = bitfieldExtract(texel_weight_data[texel_index], texel_bitsread, 1); bit = bitfieldExtract(texel_weight_data[texel_index], texel_bitsread, 1);
texel_bitsread++; ++texel_bitsread;
total_texel_bitsread++; ++total_texel_bitsread;
if (texel_bitsread == 8) { if (texel_bitsread == 8) {
texel_index++; ++texel_index;
texel_bitsread = 0; texel_bitsread = 0;
} }
} else { } else {
bit = bitfieldExtract(color_endpoint_data[color_index], color_bitsread, 1); bit = bitfieldExtract(color_endpoint_data[color_index], color_bitsread, 1);
color_bitsread++; ++color_bitsread;
total_color_bitsread++; ++total_color_bitsread;
if (color_bitsread == 8) { if (color_bitsread == 8) {
color_index++; ++color_index;
color_bitsread = 0; color_bitsread = 0;
} }
} }
@ -418,29 +431,23 @@ uint StreamColorBits(uint num_bits) {
return ret; return ret;
} }
EncodingData result_vector[100];
int result_index = 0;
EncodingData texel_vector[100];
int texel_vector_index = 0;
void ResultEmplaceBack(EncodingData val) { void ResultEmplaceBack(EncodingData val) {
if (texel_flag) { if (texel_flag) {
texel_vector[texel_vector_index] = val; texel_vector[texel_vector_index] = val;
texel_vector_index++; ++texel_vector_index;
} else { } else {
result_vector[result_index] = val; result_vector[result_index] = val;
result_index++; ++result_index;
} }
} }
// Returns the number of bits required to encode n_vals values. // Returns the number of bits required to encode n_vals values.
uint GetBitLength(uint n_vals, uint encoding_index) { uint GetBitLength(uint n_vals, uint encoding_index) {
uint total_bits = encoding_values[encoding_index].num_bits * n_vals; uint total_bits = encoding_values[encoding_index].num_bits * n_vals;
if (encoding_values[encoding_index].encoding == Trit) { if (encoding_values[encoding_index].encoding == TRIT) {
total_bits += div5_ceil(n_vals * 8); total_bits += Div5Ceil(n_vals * 8);
} else if (encoding_values[encoding_index].encoding == Quint) { } else if (encoding_values[encoding_index].encoding == QUINT) {
total_bits += div3_ceil(n_vals * 7); total_bits += Div3Ceil(n_vals * 7);
} }
return total_bits; return total_bits;
} }
@ -475,7 +482,7 @@ uint BitsOp(uint bits, uint start, uint end) {
return ((bits >> start) & mask); return ((bits >> start) & mask);
} }
void DecodeQuintBlock(uint num_bits) { // Value number of bits void DecodeQuintBlock(uint num_bits) {
uint m[3]; uint m[3];
uint q[3]; uint q[3];
uint Q; uint Q;
@ -499,7 +506,6 @@ void DecodeQuintBlock(uint num_bits) { // Value number of bits
q[2] = BitsOp(Q, 5, 6); q[2] = BitsOp(Q, 5, 6);
C = BitsOp(Q, 0, 4); C = BitsOp(Q, 0, 4);
} }
if (BitsOp(C, 0, 2) == 5) { if (BitsOp(C, 0, 2) == 5) {
q[1] = 4; q[1] = 4;
q[0] = BitsOp(C, 3, 4); q[0] = BitsOp(C, 3, 4);
@ -508,10 +514,9 @@ void DecodeQuintBlock(uint num_bits) { // Value number of bits
q[0] = BitsOp(C, 0, 2); q[0] = BitsOp(C, 0, 2);
} }
} }
for (uint i = 0; i < 3; i++) { for (uint i = 0; i < 3; i++) {
EncodingData val; EncodingData val;
val.encoding = Quint; val.encoding = QUINT;
val.num_bits = num_bits; val.num_bits = num_bits;
val.bit_value = m[i]; val.bit_value = m[i];
val.quint_trit_value = q[i]; val.quint_trit_value = q[i];
@ -563,7 +568,7 @@ void DecodeTritBlock(uint num_bits) {
} }
for (uint i = 0; i < 5; i++) { for (uint i = 0; i < 5; i++) {
EncodingData val; EncodingData val;
val.encoding = Trit; val.encoding = TRIT;
val.num_bits = num_bits; val.num_bits = num_bits;
val.bit_value = m[i]; val.bit_value = m[i];
val.quint_trit_value = t[i]; val.quint_trit_value = t[i];
@ -576,17 +581,15 @@ void DecodeIntegerSequence(uint max_range, uint num_values) {
uint vals_decoded = 0; uint vals_decoded = 0;
while (vals_decoded < num_values) { while (vals_decoded < num_values) {
switch (val.encoding) { switch (val.encoding) {
case Quint: case QUINT:
DecodeQuintBlock(val.num_bits); DecodeQuintBlock(val.num_bits);
vals_decoded += 3; vals_decoded += 3;
break; break;
case TRIT:
case Trit:
DecodeTritBlock(val.num_bits); DecodeTritBlock(val.num_bits);
vals_decoded += 5; vals_decoded += 5;
break; break;
case JUST_BITS:
case JustBits:
val.bit_value = StreamColorBits(val.num_bits); val.bit_value = StreamColorBits(val.num_bits);
ResultEmplaceBack(val); ResultEmplaceBack(val);
vals_decoded++; vals_decoded++;
@ -604,21 +607,21 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
int range = 256; int range = 256;
while (--range > 0) { while (--range > 0) {
EncodingData val = encoding_values[range]; EncodingData val = encoding_values[range];
uint bitLength = GetBitLength(num_values, range); uint bit_length = GetBitLength(num_values, range);
if (bitLength <= color_data_bits) { if (bit_length <= color_data_bits) {
while (--range > 0) { while (--range > 0) {
EncodingData newval = encoding_values[range]; EncodingData newval = encoding_values[range];
if (newval.encoding != val.encoding && newval.num_bits != val.num_bits) { if (newval.encoding != val.encoding && newval.num_bits != val.num_bits) {
break; break;
} }
} }
range++; ++range;
break; break;
} }
} }
DecodeIntegerSequence(range, num_values); DecodeIntegerSequence(range, num_values);
uint out_index = 0; uint out_index = 0;
for (int itr = 0; itr < result_index; itr++) { for (int itr = 0; itr < result_index; ++itr) {
if (out_index >= num_values) { if (out_index >= num_values) {
break; break;
} }
@ -628,77 +631,83 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
uint A = 0, B = 0, C = 0, D = 0; uint A = 0, B = 0, C = 0, D = 0;
A = ReplicateBitTo9((bitval & 1)); A = ReplicateBitTo9((bitval & 1));
switch (val.encoding) { switch (val.encoding) {
case JustBits: case JUST_BITS:
color_values[out_index++] = FastReplicateTo8(bitval, bitlen); color_values[out_index++] = FastReplicateTo8(bitval, bitlen);
break; break;
case Trit: { case TRIT: {
D = val.quint_trit_value; D = val.quint_trit_value;
switch (bitlen) { switch (bitlen) {
case 1: { case 1:
C = 204; C = 204;
} break; break;
case 2: { case 2: {
C = 93; C = 93;
uint b = (bitval >> 1) & 1; uint b = (bitval >> 1) & 1;
B = (b << 8) | (b << 4) | (b << 2) | (b << 1); B = (b << 8) | (b << 4) | (b << 2) | (b << 1);
} break; break;
}
case 3: { case 3: {
C = 44; C = 44;
uint cb = (bitval >> 1) & 3; uint cb = (bitval >> 1) & 3;
B = (cb << 7) | (cb << 2) | cb; B = (cb << 7) | (cb << 2) | cb;
} break; break;
}
case 4: { case 4: {
C = 22; C = 22;
uint dcb = (bitval >> 1) & 7; uint dcb = (bitval >> 1) & 7;
B = (dcb << 6) | dcb; B = (dcb << 6) | dcb;
} break; break;
}
case 5: { case 5: {
C = 11; C = 11;
uint edcb = (bitval >> 1) & 0xF; uint edcb = (bitval >> 1) & 0xF;
B = (edcb << 5) | (edcb >> 2); B = (edcb << 5) | (edcb >> 2);
} break; break;
}
case 6: { case 6: {
C = 5; C = 5;
uint fedcb = (bitval >> 1) & 0x1F; uint fedcb = (bitval >> 1) & 0x1F;
B = (fedcb << 4) | (fedcb >> 4); B = (fedcb << 4) | (fedcb >> 4);
} break; break;
} }
} break; }
case Quint: { break;
}
case QUINT: {
D = val.quint_trit_value; D = val.quint_trit_value;
switch (bitlen) { switch (bitlen) {
case 1: { case 1:
C = 113; C = 113;
} break; break;
case 2: { case 2: {
C = 54; C = 54;
uint b = (bitval >> 1) & 1; uint b = (bitval >> 1) & 1;
B = (b << 8) | (b << 3) | (b << 2); B = (b << 8) | (b << 3) | (b << 2);
} break; break;
}
case 3: { case 3: {
C = 26; C = 26;
uint cb = (bitval >> 1) & 3; uint cb = (bitval >> 1) & 3;
B = (cb << 7) | (cb << 1) | (cb >> 1); B = (cb << 7) | (cb << 1) | (cb >> 1);
} break; break;
}
case 4: { case 4: {
C = 13; C = 13;
uint dcb = (bitval >> 1) & 7; uint dcb = (bitval >> 1) & 7;
B = (dcb << 6) | (dcb >> 1); B = (dcb << 6) | (dcb >> 1);
} break; break;
}
case 5: { case 5: {
C = 6; C = 6;
uint edcb = (bitval >> 1) & 0xF; uint edcb = (bitval >> 1) & 0xF;
B = (edcb << 5) | (edcb >> 3); B = (edcb << 5) | (edcb >> 3);
} break; break;
} }
} break;
} }
break;
if (val.encoding != JustBits) { }
}
if (val.encoding != JUST_BITS) {
uint T = (D * C) + B; uint T = (D * C) + B;
T ^= A; T ^= A;
T = (A & 0x80) | (T >> 2); T = (A & 0x80) | (T >> 2);
@ -709,18 +718,18 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
ivec2 BitTransferSigned(int a, int b) { ivec2 BitTransferSigned(int a, int b) {
ivec2 transferred; ivec2 transferred;
transferred[1] = b >> 1; transferred.y = b >> 1;
transferred[1] |= a & 0x80; transferred.y |= a & 0x80;
transferred[0] = a >> 1; transferred.x = a >> 1;
transferred[0] &= 0x3F; transferred.x &= 0x3F;
if ((transferred[0] & 0x20) > 0) { if ((transferred.x & 0x20) > 0) {
transferred[0] -= 0x40; transferred.x -= 0x40;
} }
return transferred; return transferred;
} }
uvec4 ClampByte(ivec4 color) { uvec4 ClampByte(ivec4 color) {
for (uint i = 0; i < 4; i++) { for (uint i = 0; i < 4; ++i) {
color[i] = (color[i] < 0) ? 0 : ((color[i] > 255) ? 255 : color[i]); color[i] = (color[i] < 0) ? 0 : ((color[i] > 255) ? 255 : color[i]);
} }
return uvec4(color); return uvec4(color);
@ -730,8 +739,6 @@ ivec4 BlueContract(int a, int r, int g, int b) {
return ivec4(a, (r + b) >> 1, (g + b) >> 1, b); return ivec4(a, (r + b) >> 1, (g + b) >> 1, b);
} }
int colvals_index = 0;
void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32], void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
uint color_endpoint_mode) { uint color_endpoint_mode) {
#define READ_UINT_VALUES(N) \ #define READ_UINT_VALUES(N) \
@ -751,40 +758,40 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
READ_UINT_VALUES(2) READ_UINT_VALUES(2)
ep1 = uvec4(0xFF, v[0], v[0], v[0]); ep1 = uvec4(0xFF, v[0], v[0], v[0]);
ep2 = uvec4(0xFF, v[1], v[1], v[1]); ep2 = uvec4(0xFF, v[1], v[1], v[1]);
} break; break;
}
case 1: { case 1: {
READ_UINT_VALUES(2) READ_UINT_VALUES(2)
uint L0 = (v[0] >> 2) | (v[1] & 0xC0); uint L0 = (v[0] >> 2) | (v[1] & 0xC0);
uint L1 = max(L0 + (v[1] & 0x3F), 0xFFU); uint L1 = max(L0 + (v[1] & 0x3F), 0xFFU);
ep1 = uvec4(0xFF, L0, L0, L0); ep1 = uvec4(0xFF, L0, L0, L0);
ep2 = uvec4(0xFF, L1, L1, L1); ep2 = uvec4(0xFF, L1, L1, L1);
} break; break;
}
case 4: { case 4: {
READ_UINT_VALUES(4) READ_UINT_VALUES(4)
ep1 = uvec4(v[2], v[0], v[0], v[0]); ep1 = uvec4(v[2], v[0], v[0], v[0]);
ep2 = uvec4(v[3], v[1], v[1], v[1]); ep2 = uvec4(v[3], v[1], v[1], v[1]);
} break; break;
}
case 5: { case 5: {
READ_INT_VALUES(4) READ_INT_VALUES(4)
ivec2 transferred = BitTransferSigned(v[1], v[0]); ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0]; v[1] = transferred.x;
v[0] = transferred[1]; v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]); transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0]; v[3] = transferred.x;
v[2] = transferred[1]; v[2] = transferred.y;
ep1 = ClampByte(ivec4(v[2], v[0], v[0], v[0])); ep1 = ClampByte(ivec4(v[2], v[0], v[0], v[0]));
ep2 = ClampByte(ivec4((v[2] + v[3]), v[0] + v[1], v[0] + v[1], v[0] + v[1])); ep2 = ClampByte(ivec4((v[2] + v[3]), v[0] + v[1], v[0] + v[1], v[0] + v[1]));
} break; break;
}
case 6: { case 6: {
READ_UINT_VALUES(4) READ_UINT_VALUES(4)
ep1 = uvec4(0xFF, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8); ep1 = uvec4(0xFF, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8);
ep2 = uvec4(0xFF, v[0], v[1], v[2]); ep2 = uvec4(0xFF, v[0], v[1], v[2]);
} break; break;
}
case 8: { case 8: {
READ_UINT_VALUES(6) READ_UINT_VALUES(6)
if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) { if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) {
@ -794,19 +801,19 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = uvec4(BlueContract(0xFF, int(v[1]), int(v[3]), int(v[5]))); ep1 = uvec4(BlueContract(0xFF, int(v[1]), int(v[3]), int(v[5])));
ep2 = uvec4(BlueContract(0xFF, int(v[0]), int(v[2]), int(v[4]))); ep2 = uvec4(BlueContract(0xFF, int(v[0]), int(v[2]), int(v[4])));
} }
} break; break;
}
case 9: { case 9: {
READ_INT_VALUES(6) READ_INT_VALUES(6)
ivec2 transferred = BitTransferSigned(v[1], v[0]); ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0]; v[1] = transferred.x;
v[0] = transferred[1]; v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]); transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0]; v[3] = transferred.x;
v[2] = transferred[1]; v[2] = transferred.y;
transferred = BitTransferSigned(v[5], v[4]); transferred = BitTransferSigned(v[5], v[4]);
v[5] = transferred[0]; v[5] = transferred.x;
v[4] = transferred[1]; v[4] = transferred.y;
if (v[1] + v[3] + v[5] >= 0) { if (v[1] + v[3] + v[5] >= 0) {
ep1 = ClampByte(ivec4(0xFF, v[0], v[2], v[4])); ep1 = ClampByte(ivec4(0xFF, v[0], v[2], v[4]));
ep2 = ClampByte(ivec4(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5])); ep2 = ClampByte(ivec4(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5]));
@ -814,14 +821,14 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = ClampByte(BlueContract(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5])); ep1 = ClampByte(BlueContract(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5]));
ep2 = ClampByte(BlueContract(0xFF, v[0], v[2], v[4])); ep2 = ClampByte(BlueContract(0xFF, v[0], v[2], v[4]));
} }
} break; break;
}
case 10: { case 10: {
READ_UINT_VALUES(6) READ_UINT_VALUES(6)
ep1 = uvec4(v[4], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8); ep1 = uvec4(v[4], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8);
ep2 = uvec4(v[5], v[0], v[1], v[2]); ep2 = uvec4(v[5], v[0], v[1], v[2]);
} break; break;
}
case 12: { case 12: {
READ_UINT_VALUES(8) READ_UINT_VALUES(8)
if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) { if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) {
@ -831,24 +838,24 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = uvec4(BlueContract(int(v[7]), int(v[1]), int(v[3]), int(v[5]))); ep1 = uvec4(BlueContract(int(v[7]), int(v[1]), int(v[3]), int(v[5])));
ep2 = uvec4(BlueContract(int(v[6]), int(v[0]), int(v[2]), int(v[4]))); ep2 = uvec4(BlueContract(int(v[6]), int(v[0]), int(v[2]), int(v[4])));
} }
} break; break;
}
case 13: { case 13: {
READ_INT_VALUES(8) READ_INT_VALUES(8)
ivec2 transferred = BitTransferSigned(v[1], v[0]); ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0]; v[1] = transferred.x;
v[0] = transferred[1]; v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]); transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0]; v[3] = transferred.x;
v[2] = transferred[1]; v[2] = transferred.y;
transferred = BitTransferSigned(v[5], v[4]); transferred = BitTransferSigned(v[5], v[4]);
v[5] = transferred[0]; v[5] = transferred.x;
v[4] = transferred[1]; v[4] = transferred.y;
transferred = BitTransferSigned(v[7], v[6]); transferred = BitTransferSigned(v[7], v[6]);
v[7] = transferred[0]; v[7] = transferred.x;
v[6] = transferred[1]; v[6] = transferred.y;
if (v[1] + v[3] + v[5] >= 0) { if (v[1] + v[3] + v[5] >= 0) {
ep1 = ClampByte(ivec4(v[6], v[0], v[2], v[4])); ep1 = ClampByte(ivec4(v[6], v[0], v[2], v[4]));
@ -857,7 +864,8 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = ClampByte(BlueContract(v[6] + v[7], v[0] + v[1], v[2] + v[3], v[4] + v[5])); ep1 = ClampByte(BlueContract(v[6] + v[7], v[0] + v[1], v[2] + v[3], v[4] + v[5]));
ep2 = ClampByte(BlueContract(v[6], v[0], v[2], v[4])); ep2 = ClampByte(BlueContract(v[6], v[0], v[2], v[4]));
} }
} break; break;
}
} }
#undef READ_UINT_VALUES #undef READ_UINT_VALUES
#undef READ_INT_VALUES #undef READ_INT_VALUES
@ -870,52 +878,61 @@ uint UnquantizeTexelWeight(EncodingData val) {
uint B = 0, C = 0, D = 0; uint B = 0, C = 0, D = 0;
uint result = 0; uint result = 0;
switch (val.encoding) { switch (val.encoding) {
case JustBits: case JUST_BITS:
result = FastReplicateTo6(bitval, bitlen); result = FastReplicateTo6(bitval, bitlen);
break; break;
case Trit: { case TRIT: {
D = val.quint_trit_value; D = val.quint_trit_value;
switch (bitlen) { switch (bitlen) {
case 0: { case 0: {
uint results[3] = {0, 32, 63}; uint results[3] = {0, 32, 63};
result = results[D]; result = results[D];
} break; break;
}
case 1: { case 1: {
C = 50; C = 50;
} break; break;
}
case 2: { case 2: {
C = 23; C = 23;
uint b = (bitval >> 1) & 1; uint b = (bitval >> 1) & 1;
B = (b << 6) | (b << 2) | b; B = (b << 6) | (b << 2) | b;
} break; break;
}
case 3: { case 3: {
C = 11; C = 11;
uint cb = (bitval >> 1) & 3; uint cb = (bitval >> 1) & 3;
B = (cb << 5) | cb; B = (cb << 5) | cb;
} break; break;
}
default: default:
break; break;
} }
} break; break;
case Quint: { }
case QUINT: {
D = val.quint_trit_value; D = val.quint_trit_value;
switch (bitlen) { switch (bitlen) {
case 0: { case 0: {
uint results[5] = {0, 16, 32, 47, 63}; uint results[5] = {0, 16, 32, 47, 63};
result = results[D]; result = results[D];
} break; break;
}
case 1: { case 1: {
C = 28; C = 28;
} break; break;
}
case 2: { case 2: {
C = 13; C = 13;
uint b = (bitval >> 1) & 1; uint b = (bitval >> 1) & 1;
B = (b << 6) | (b << 1); B = (b << 6) | (b << 1);
} break; break;
} }
} break;
} }
if (val.encoding != JustBits && bitlen > 0) { break;
}
}
if (val.encoding != JUST_BITS && bitlen > 0) {
result = D * C + B; result = D * C + B;
result ^= A; result ^= A;
result = (A & 0x20) | (result >> 2); result = (A & 0x20) | (result >> 2);
@ -926,7 +943,7 @@ uint UnquantizeTexelWeight(EncodingData val) {
return result; return result;
} }
void UnquantizeTexelWeights(out uint outbuffer[2][144], bool dual_plane, uvec2 size) { void UnquantizeTexelWeights(bool dual_plane, uvec2 size) {
uint weight_idx = 0; uint weight_idx = 0;
uint unquantized[2][144]; uint unquantized[2][144];
uint area = size.x * size.y; uint area = size.x * size.y;
@ -977,7 +994,7 @@ void UnquantizeTexelWeights(out uint outbuffer[2][144], bool dual_plane, uvec2 s
if ((v0 + size.x + 1) < (area)) { if ((v0 + size.x + 1) < (area)) {
p.w = unquantized[plane][(v0 + size.x + 1)]; p.w = unquantized[plane][(v0 + size.x + 1)];
} }
outbuffer[plane][t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4; unquantized_texel_weights[plane][t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4;
} }
} }
} }
@ -1015,25 +1032,25 @@ int FindLayout(uint mode) {
} }
TexelWeightParams DecodeBlockInfo(uint block_index) { TexelWeightParams DecodeBlockInfo(uint block_index) {
TexelWeightParams params = TexelWeightParams(uvec2(0), false, 0, false, false, false); TexelWeightParams params = TexelWeightParams(uvec2(0), 0, false, false, false, false);
uint mode = StreamBits(11); uint mode = StreamBits(11);
if ((mode & 0x1ff) == 0x1fc) { if ((mode & 0x1ff) == 0x1fc) {
if ((mode & 0x200) != 0) { if ((mode & 0x200) != 0) {
params.VoidExtentHDR = true; params.void_extent_hdr = true;
} else { } else {
params.VoidExtentLDR = true; params.void_extent_ldr = true;
} }
if ((mode & 0x400) == 0 || StreamBits(1) == 0) { if ((mode & 0x400) == 0 || StreamBits(1) == 0) {
params.Error = true; params.error_state = true;
} }
return params; return params;
} }
if ((mode & 0xf) == 0) { if ((mode & 0xf) == 0) {
params.Error = true; params.error_state = true;
return params; return params;
} }
if ((mode & 3) == 0 && (mode & 0x1c0) == 0x1c0) { if ((mode & 3) == 0 && (mode & 0x1c0) == 0x1c0) {
params.Error = true; params.error_state = true;
return params; return params;
} }
uint A, B; uint A, B;
@ -1084,7 +1101,7 @@ TexelWeightParams DecodeBlockInfo(uint block_index) {
params.size = uvec2(A + 6, B + 6); params.size = uvec2(A + 6, B + 6);
break; break;
default: default:
params.Error = true; params.error_state = true;
break; break;
} }
params.dual_plane = (mode_layout != 9) && ((mode & 0x400) != 0); params.dual_plane = (mode_layout != 9) && ((mode & 0x400) != 0);
@ -1117,7 +1134,6 @@ void FillVoidExtentLDR(ivec3 coord, uint block_index) {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
StreamBits(13); StreamBits(13);
} }
uint r_u = StreamBits(16); uint r_u = StreamBits(16);
uint g_u = StreamBits(16); uint g_u = StreamBits(16);
uint b_u = StreamBits(16); uint b_u = StreamBits(16);
@ -1135,15 +1151,15 @@ void FillVoidExtentLDR(ivec3 coord, uint block_index) {
void DecompressBlock(ivec3 coord, uint block_index) { void DecompressBlock(ivec3 coord, uint block_index) {
TexelWeightParams params = DecodeBlockInfo(block_index); TexelWeightParams params = DecodeBlockInfo(block_index);
if (params.Error) { if (params.error_state) {
FillError(coord); FillError(coord);
return; return;
} }
if (params.VoidExtentHDR) { if (params.void_extent_hdr) {
FillError(coord); FillError(coord);
return; return;
} }
if (params.VoidExtentLDR) { if (params.void_extent_ldr) {
FillVoidExtentLDR(coord, block_index); FillVoidExtentLDR(coord, block_index);
return; return;
} }
@ -1204,7 +1220,7 @@ void DecompressBlock(ivec3 coord, uint block_index) {
int nb = int(min(remaining_bits, 8U)); int nb = int(min(remaining_bits, 8U));
uint b = StreamBits(nb); uint b = StreamBits(nb);
color_endpoint_data[ced_pointer] = uint(bitfieldExtract(b, 0, nb)); color_endpoint_data[ced_pointer] = uint(bitfieldExtract(b, 0, nb));
ced_pointer++; ++ced_pointer;
remaining_bits -= nb; remaining_bits -= nb;
} }
plane_index = int(StreamBits(plane_selector_bits)); plane_index = int(StreamBits(plane_selector_bits));
@ -1262,13 +1278,12 @@ void DecompressBlock(ivec3 coord, uint block_index) {
uint( uint(
((1 << (GetPackedBitSize(params.size, params.dual_plane, params.max_weight) % 8)) - 1)); ((1 << (GetPackedBitSize(params.size, params.dual_plane, params.max_weight) % 8)) - 1));
for (uint i = 0; i < 16 - clear_byte_start; i++) { for (uint i = 0; i < 16 - clear_byte_start; i++) {
texel_weight_data[clear_byte_start + i] = uint(0U); texel_weight_data[clear_byte_start + i] = 0U;
} }
texel_flag = true; // use texel "vector" and bit stream in integer decoding texel_flag = true; // use texel "vector" and bit stream in integer decoding
DecodeIntegerSequence(params.max_weight, GetNumWeightValues(params.size, params.dual_plane)); DecodeIntegerSequence(params.max_weight, GetNumWeightValues(params.size, params.dual_plane));
uint weights[2][144]; UnquantizeTexelWeights(params.dual_plane, params.size);
UnquantizeTexelWeights(weights, params.dual_plane, params.size);
for (uint j = 0; j < block_dims.y; j++) { for (uint j = 0; j < block_dims.y; j++) {
for (uint i = 0; i < block_dims.x; i++) { for (uint i = 0; i < block_dims.x; i++) {
@ -1283,7 +1298,7 @@ void DecompressBlock(ivec3 coord, uint block_index) {
if (params.dual_plane && (((plane_index + 1) & 3) == c)) { if (params.dual_plane && (((plane_index + 1) & 3) == c)) {
plane_vec[c] = 1; plane_vec[c] = 1;
} }
weight_vec[c] = weights[plane_vec[c]][j * block_dims.x + i]; weight_vec[c] = unquantized_texel_weights[plane_vec[c]][j * block_dims.x + i];
} }
vec4 Cf = vec4((C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) >> 6); vec4 Cf = vec4((C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) >> 6);
p = (Cf / 65535.0); p = (Cf / 65535.0);
@ -1309,8 +1324,8 @@ void main() {
offset += swizzle; offset += swizzle;
const ivec3 coord = ivec3(gl_GlobalInvocationID * uvec3(block_dims, 1)); const ivec3 coord = ivec3(gl_GlobalInvocationID * uvec3(block_dims, 1));
uint block_index = pos.z * num_image_blocks.x * num_image_blocks.y + uint block_index =
pos.y * num_image_blocks.x + pos.x; pos.z * num_image_blocks.x * num_image_blocks.y + pos.y * num_image_blocks.x + pos.x;
current_index = 0; current_index = 0;
bitsread = 0; bitsread = 0;

8
src/video_core/host_shaders/opengl_copy_bgra.comp
View file

@ -6,10 +6,10 @@
layout (local_size_x = 4, local_size_y = 4) in; layout (local_size_x = 4, local_size_y = 4) in;
layout(binding = 0, rgba8) readonly uniform image2D bgr_input; layout(binding = 0, rgba8) readonly uniform image2DArray bgr_input;
layout(binding = 1, rgba8) writeonly uniform image2D bgr_output; layout(binding = 1, rgba8) writeonly uniform image2DArray bgr_output;
void main() { void main() {
vec4 color = imageLoad(bgr_input, ivec2(gl_GlobalInvocationID.xy)); vec4 color = imageLoad(bgr_input, ivec3(gl_GlobalInvocationID));
imageStore(bgr_output, ivec2(gl_GlobalInvocationID.xy), color.bgra); imageStore(bgr_output, ivec3(gl_GlobalInvocationID), color.bgra);
} }

2
src/video_core/renderer_opengl/gl_texture_cache.cpp
View file

@ -307,7 +307,7 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
[[nodiscard]] bool CanBeAccelerated(const TextureCacheRuntime& runtime, [[nodiscard]] bool CanBeAccelerated(const TextureCacheRuntime& runtime,
const VideoCommon::ImageInfo& info) { const VideoCommon::ImageInfo& info) {
return (!runtime.HasNativeASTC() && IsPixelFormatASTC(info.format)); return !runtime.HasNativeASTC() && IsPixelFormatASTC(info.format);
// Disable other accelerated uploads for now as they don't implement swizzled uploads // Disable other accelerated uploads for now as they don't implement swizzled uploads
return false; return false;
switch (info.type) { switch (info.type) {

5
src/video_core/renderer_opengl/gl_texture_cache.h
View file

@ -86,6 +86,11 @@ public:
FormatProperties FormatInfo(VideoCommon::ImageType type, GLenum internal_format) const; FormatProperties FormatInfo(VideoCommon::ImageType type, GLenum internal_format) const;
bool HasNativeBgr() const noexcept {
// OpenGL does not have native support for the BGR internal format
return false;
}
bool HasBrokenTextureViewFormats() const noexcept { bool HasBrokenTextureViewFormats() const noexcept {
return has_broken_texture_view_formats; return has_broken_texture_view_formats;
} }

59
src/video_core/renderer_opengl/util_shaders.cpp
View file

@ -14,7 +14,6 @@
#include "video_core/host_shaders/block_linear_unswizzle_2d_comp.h" #include "video_core/host_shaders/block_linear_unswizzle_2d_comp.h"
#include "video_core/host_shaders/block_linear_unswizzle_3d_comp.h" #include "video_core/host_shaders/block_linear_unswizzle_3d_comp.h"
#include "video_core/host_shaders/opengl_copy_bc4_comp.h" #include "video_core/host_shaders/opengl_copy_bc4_comp.h"
#include "video_core/host_shaders/opengl_copy_bgr16_comp.h"
#include "video_core/host_shaders/opengl_copy_bgra_comp.h" #include "video_core/host_shaders/opengl_copy_bgra_comp.h"
#include "video_core/host_shaders/pitch_unswizzle_comp.h" #include "video_core/host_shaders/pitch_unswizzle_comp.h"
#include "video_core/renderer_opengl/gl_resource_manager.h" #include "video_core/renderer_opengl/gl_resource_manager.h"
@ -52,6 +51,12 @@ OGLProgram MakeProgram(std::string_view source) {
return program; return program;
} }
size_t CopyBufferSize(const VideoCommon::ImageCopy& copy) {
const size_t size = static_cast<size_t>(copy.extent.width * copy.extent.height *
copy.src_subresource.num_layers);
return size;
}
} // Anonymous namespace } // Anonymous namespace
UtilShaders::UtilShaders(ProgramManager& program_manager_) UtilShaders::UtilShaders(ProgramManager& program_manager_)
@ -59,7 +64,6 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
block_linear_unswizzle_2d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_2D_COMP)), block_linear_unswizzle_2d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_2D_COMP)),
block_linear_unswizzle_3d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_3D_COMP)), block_linear_unswizzle_3d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_3D_COMP)),
pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)), pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)),
copy_bgr16_program(MakeProgram(OPENGL_COPY_BGR16_COMP)),
copy_bgra_program(MakeProgram(OPENGL_COPY_BGRA_COMP)), copy_bgra_program(MakeProgram(OPENGL_COPY_BGRA_COMP)),
copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)) { copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)) {
const auto swizzle_table = Tegra::Texture::MakeSwizzleTable(); const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
@ -287,29 +291,35 @@ void UtilShaders::CopyBGR(Image& dst_image, Image& src_image,
static constexpr GLuint BINDING_OUTPUT_IMAGE = 1; static constexpr GLuint BINDING_OUTPUT_IMAGE = 1;
static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0}; static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0};
const u32 bytes_per_block = BytesPerBlock(dst_image.info.format); const u32 bytes_per_block = BytesPerBlock(dst_image.info.format);
if (bytes_per_block == 2) { switch (bytes_per_block) {
case 2:
// BGR565 Copy // BGR565 Copy
program_manager.BindHostCompute(copy_bgr16_program.handle);
for (const ImageCopy& copy : copies) { for (const ImageCopy& copy : copies) {
ASSERT(copy.src_offset == zero_offset); ASSERT(copy.src_offset == zero_offset);
ASSERT(copy.dst_offset == zero_offset); ASSERT(copy.dst_offset == zero_offset);
bgr_copy_pass.Execute(dst_image, src_image, copy); bgr_copy_pass.Execute(dst_image, src_image, copy);
} }
} else if (bytes_per_block == 4) { break;
case 4: {
// BGRA8 Copy // BGRA8 Copy
program_manager.BindHostCompute(copy_bgra_program.handle); program_manager.BindHostCompute(copy_bgra_program.handle);
constexpr GLenum format = GL_RGBA8; constexpr GLenum FORMAT = GL_RGBA8;
for (const ImageCopy& copy : copies) { for (const ImageCopy& copy : copies) {
ASSERT(copy.src_offset == zero_offset); ASSERT(copy.src_offset == zero_offset);
ASSERT(copy.dst_offset == zero_offset); ASSERT(copy.dst_offset == zero_offset);
glBindImageTexture(BINDING_INPUT_IMAGE, src_image.StorageHandle(), glBindImageTexture(BINDING_INPUT_IMAGE, src_image.StorageHandle(),
copy.src_subresource.base_level, GL_FALSE, 0, GL_READ_ONLY, format); copy.src_subresource.base_level, GL_FALSE, 0, GL_READ_ONLY, FORMAT);
glBindImageTexture(BINDING_OUTPUT_IMAGE, dst_image.StorageHandle(), glBindImageTexture(BINDING_OUTPUT_IMAGE, dst_image.StorageHandle(),
copy.dst_subresource.base_level, GL_FALSE, 0, GL_WRITE_ONLY, format); copy.dst_subresource.base_level, GL_FALSE, 0, GL_WRITE_ONLY, FORMAT);
glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth); glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth);
} }
}
program_manager.RestoreGuestCompute(); program_manager.RestoreGuestCompute();
break;
}
default:
UNREACHABLE();
break;
}
} }
GLenum StoreFormat(u32 bytes_per_block) { GLenum StoreFormat(u32 bytes_per_block) {
@ -331,54 +341,35 @@ GLenum StoreFormat(u32 bytes_per_block) {
void Bgr565CopyPass::Execute(const Image& dst_image, const Image& src_image, void Bgr565CopyPass::Execute(const Image& dst_image, const Image& src_image,
const ImageCopy& copy) { const ImageCopy& copy) {
static constexpr GLuint BINDING_INPUT_IMAGE = 0;
static constexpr GLenum format = GL_RGB565;
static constexpr GLenum target = GL_TEXTURE_2D_ARRAY;
if (CopyBufferCreationNeeded(copy)) { if (CopyBufferCreationNeeded(copy)) {
CreateNewCopyBuffer(copy, target, format); CreateNewCopyBuffer(copy, GL_TEXTURE_2D_ARRAY, GL_RGB565);
} }
// Copy from source to PBO // Copy from source to PBO
glMemoryBarrier(GL_PIXEL_BUFFER_BARRIER_BIT);
glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1);
glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle); glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle);
glBindTexture(target, src_image.Handle());
glFinish();
glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width); glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width);
glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height, glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
copy.src_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, copy.src_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
static_cast<GLsizei>(bgr16_pbo_size), 0); static_cast<GLsizei>(bgr16_pbo_size), 0);
// Swizzle PBO in compute shader // Copy from PBO to destination in reverse order
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_INPUT_IMAGE, bgr16_pbo.handle);
glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth);
// Copy from PBO to destination
glMemoryBarrier(GL_PIXEL_BUFFER_BARRIER_BIT);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr16_pbo.handle); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr16_pbo.handle);
glBindTexture(target, dst_image.Handle());
glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width); glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width);
glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height, glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
copy.dst_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0); copy.dst_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, 0);
// Unbind the buffer
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
} }
bool Bgr565CopyPass::CopyBufferCreationNeeded(const ImageCopy& copy) { bool Bgr565CopyPass::CopyBufferCreationNeeded(const ImageCopy& copy) {
return bgr16_pbo_size < return bgr16_pbo_size < CopyBufferSize(copy) * sizeof(u16);
(copy.extent.width * copy.extent.height * copy.src_subresource.num_layers * sizeof(u16));
} }
void Bgr565CopyPass::CreateNewCopyBuffer(const ImageCopy& copy, GLenum target, GLuint format) { void Bgr565CopyPass::CreateNewCopyBuffer(const ImageCopy& copy, GLenum target, GLuint format) {
bgr16_pbo.Release(); bgr16_pbo.Release();
bgr16_pbo.Create(); bgr16_pbo.Create();
bgr16_pbo_size = bgr16_pbo_size = CopyBufferSize(copy) * sizeof(u16);
(copy.extent.width * copy.extent.height * copy.src_subresource.num_layers * sizeof(u16));
glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle); glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle);
glBufferData(GL_PIXEL_PACK_BUFFER, bgr16_pbo_size, 0, GL_STREAM_DRAW); glNamedBufferData(bgr16_pbo.handle, bgr16_pbo_size, 0, GL_STREAM_COPY);
} }
} // namespace OpenGL } // namespace OpenGL

8
src/video_core/renderer_opengl/util_shaders.h
View file

@ -28,12 +28,11 @@ public:
const VideoCommon::ImageCopy& copy); const VideoCommon::ImageCopy& copy);
private: private:
OGLBuffer bgr16_pbo{};
size_t bgr16_pbo_size{};
[[nodiscard]] bool CopyBufferCreationNeeded(const VideoCommon::ImageCopy& copy); [[nodiscard]] bool CopyBufferCreationNeeded(const VideoCommon::ImageCopy& copy);
void CreateNewCopyBuffer(const VideoCommon::ImageCopy& copy, GLenum target, GLuint format); void CreateNewCopyBuffer(const VideoCommon::ImageCopy& copy, GLenum target, GLuint format);
OGLBuffer bgr16_pbo;
size_t bgr16_pbo_size{};
}; };
class UtilShaders { class UtilShaders {
@ -69,7 +68,6 @@ private:
OGLProgram block_linear_unswizzle_2d_program; OGLProgram block_linear_unswizzle_2d_program;
OGLProgram block_linear_unswizzle_3d_program; OGLProgram block_linear_unswizzle_3d_program;
OGLProgram pitch_unswizzle_program; OGLProgram pitch_unswizzle_program;
OGLProgram copy_bgr16_program;
OGLProgram copy_bgra_program; OGLProgram copy_bgra_program;
OGLProgram copy_bc4_program; OGLProgram copy_bc4_program;

12
src/video_core/renderer_vulkan/vk_compute_pass.cpp
View file

@ -424,7 +424,7 @@ ASTCDecoderPass::ASTCDecoderPass(const Device& device_, VKScheduler& scheduler_,
ASTCDecoderPass::~ASTCDecoderPass() = default; ASTCDecoderPass::~ASTCDecoderPass() = default;
void ASTCDecoderPass::MakeDataBuffer() { void ASTCDecoderPass::MakeDataBuffer() {
constexpr auto TOTAL_BUFFER_SIZE = sizeof(ASTC_BUFFER_DATA) + sizeof(SWIZZLE_TABLE); constexpr size_t TOTAL_BUFFER_SIZE = sizeof(ASTC_BUFFER_DATA) + sizeof(SWIZZLE_TABLE);
data_buffer = device.GetLogical().CreateBuffer(VkBufferCreateInfo{ data_buffer = device.GetLogical().CreateBuffer(VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
@ -458,17 +458,16 @@ void ASTCDecoderPass::MakeDataBuffer() {
.pNext = nullptr, .pNext = nullptr,
.srcAccessMask = 0, .srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
}, });
{}, {});
}); });
} }
void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map, void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
std::span<const VideoCommon::SwizzleParameters> swizzles) { std::span<const VideoCommon::SwizzleParameters> swizzles) {
using namespace VideoCommon::Accelerated; using namespace VideoCommon::Accelerated;
const VideoCommon::Extent2D tile_size{ const std::array<u32, 2> block_dims{
.width = VideoCore::Surface::DefaultBlockWidth(image.info.format), VideoCore::Surface::DefaultBlockWidth(image.info.format),
.height = VideoCore::Surface::DefaultBlockHeight(image.info.format), VideoCore::Surface::DefaultBlockHeight(image.info.format),
}; };
scheduler.RequestOutsideRenderPassOperationContext(); scheduler.RequestOutsideRenderPassOperationContext();
if (!data_buffer) { if (!data_buffer) {
@ -498,7 +497,6 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
}; };
cmdbuf.PipelineBarrier(0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier); cmdbuf.PipelineBarrier(0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
}); });
const std::array<u32, 2> block_dims{tile_size.width, tile_size.height};
for (const VideoCommon::SwizzleParameters& swizzle : swizzles) { for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
const size_t input_offset = swizzle.buffer_offset + map.offset; const size_t input_offset = swizzle.buffer_offset + map.offset;
const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U); const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);

4
src/video_core/renderer_vulkan/vk_rasterizer.cpp
View file

@ -243,8 +243,8 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
blit_image(device, scheduler, state_tracker, descriptor_pool), blit_image(device, scheduler, state_tracker, descriptor_pool),
astc_decoder_pass(device, scheduler, descriptor_pool, staging_pool, update_descriptor_queue, astc_decoder_pass(device, scheduler, descriptor_pool, staging_pool, update_descriptor_queue,
memory_allocator), memory_allocator),
texture_cache_runtime{device, scheduler, memory_allocator, texture_cache_runtime(device, scheduler, memory_allocator, staging_pool, blit_image,
staging_pool, blit_image, astc_decoder_pass}, astc_decoder_pass),
texture_cache(texture_cache_runtime, *this, maxwell3d, kepler_compute, gpu_memory), texture_cache(texture_cache_runtime, *this, maxwell3d, kepler_compute, gpu_memory),
buffer_cache_runtime(device, memory_allocator, scheduler, staging_pool, buffer_cache_runtime(device, memory_allocator, scheduler, staging_pool,
update_descriptor_queue, descriptor_pool), update_descriptor_queue, descriptor_pool),

5
src/video_core/renderer_vulkan/vk_texture_cache.h
View file

@ -93,6 +93,11 @@ struct TextureCacheRuntime {
// No known Vulkan driver has broken image views // No known Vulkan driver has broken image views
return false; return false;
} }
bool HasNativeBgr() const noexcept {
// All known Vulkan drivers can natively handle BGR textures
return true;
}
}; };
class Image : public VideoCommon::ImageBase { class Image : public VideoCommon::ImageBase {

1
src/video_core/shader_notify.cpp
View file

@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <mutex>
#include "video_core/shader_notify.h" #include "video_core/shader_notify.h"
using namespace std::chrono_literals; using namespace std::chrono_literals;

5
src/video_core/texture_cache/image_base.cpp
View file

@ -120,9 +120,10 @@ void AddImageAlias(ImageBase& lhs, ImageBase& rhs, ImageId lhs_id, ImageId rhs_i
if (lhs.info.type == ImageType::Linear) { if (lhs.info.type == ImageType::Linear) {
base = SubresourceBase{.level = 0, .layer = 0}; base = SubresourceBase{.level = 0, .layer = 0};
} else { } else {
// We are passing relaxed formats as an option, having broken views or not won't matter // We are passing relaxed formats as an option, having broken views/bgr or not won't matter
static constexpr bool broken_views = false; static constexpr bool broken_views = false;
base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS, broken_views); static constexpr bool native_bgr = true;
base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS, broken_views, native_bgr);
} }
if (!base) { if (!base) {
LOG_ERROR(HW_GPU, "Image alias should have been flipped"); LOG_ERROR(HW_GPU, "Image alias should have been flipped");

5
src/video_core/texture_cache/image_view_base.cpp
View file

@ -24,7 +24,10 @@ ImageViewBase::ImageViewBase(const ImageViewInfo& info, const ImageInfo& image_i
.height = std::max(image_info.size.height >> range.base.level, 1u), .height = std::max(image_info.size.height >> range.base.level, 1u),
.depth = std::max(image_info.size.depth >> range.base.level, 1u), .depth = std::max(image_info.size.depth >> range.base.level, 1u),
} { } {
ASSERT_MSG(VideoCore::Surface::IsViewCompatible(image_info.format, info.format, false), const bool native_bgr =
Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::Vulkan;
ASSERT_MSG(
VideoCore::Surface::IsViewCompatible(image_info.format, info.format, false, native_bgr),
"Image view format {} is incompatible with image format {}", info.format, "Image view format {} is incompatible with image format {}", info.format,
image_info.format); image_info.format);
const bool is_async = Settings::values.use_asynchronous_gpu_emulation.GetValue(); const bool is_async = Settings::values.use_asynchronous_gpu_emulation.GetValue();

15
src/video_core/texture_cache/texture_cache.h
View file

@ -876,6 +876,7 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
return ImageId{}; return ImageId{};
} }
const bool broken_views = runtime.HasBrokenTextureViewFormats(); const bool broken_views = runtime.HasBrokenTextureViewFormats();
const bool native_bgr = runtime.HasNativeBgr();
ImageId image_id; ImageId image_id;
const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) { const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) { if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) {
@ -885,11 +886,12 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
if (existing_image.gpu_addr == gpu_addr && existing.type == info.type && if (existing_image.gpu_addr == gpu_addr && existing.type == info.type &&
existing.pitch == info.pitch && existing.pitch == info.pitch &&
IsPitchLinearSameSize(existing, info, strict_size) && IsPitchLinearSameSize(existing, info, strict_size) &&
IsViewCompatible(existing.format, info.format, broken_views)) { IsViewCompatible(existing.format, info.format, broken_views, native_bgr)) {
image_id = existing_image_id; image_id = existing_image_id;
return true; return true;
} }
} else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views)) { } else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views,
native_bgr)) {
image_id = existing_image_id; image_id = existing_image_id;
return true; return true;
} }
@ -920,6 +922,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
ImageInfo new_info = info; ImageInfo new_info = info;
const size_t size_bytes = CalculateGuestSizeInBytes(new_info); const size_t size_bytes = CalculateGuestSizeInBytes(new_info);
const bool broken_views = runtime.HasBrokenTextureViewFormats(); const bool broken_views = runtime.HasBrokenTextureViewFormats();
const bool native_bgr = runtime.HasNativeBgr();
std::vector<ImageId> overlap_ids; std::vector<ImageId> overlap_ids;
std::vector<ImageId> left_aliased_ids; std::vector<ImageId> left_aliased_ids;
std::vector<ImageId> right_aliased_ids; std::vector<ImageId> right_aliased_ids;
@ -935,8 +938,8 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
return; return;
} }
static constexpr bool strict_size = true; static constexpr bool strict_size = true;
const std::optional<OverlapResult> solution = const std::optional<OverlapResult> solution = ResolveOverlap(
ResolveOverlap(new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views); new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views, native_bgr);
if (solution) { if (solution) {
gpu_addr = solution->gpu_addr; gpu_addr = solution->gpu_addr;
cpu_addr = solution->cpu_addr; cpu_addr = solution->cpu_addr;
@ -946,10 +949,10 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
} }
static constexpr auto options = RelaxedOptions::Size | RelaxedOptions::Format; static constexpr auto options = RelaxedOptions::Size | RelaxedOptions::Format;
const ImageBase new_image_base(new_info, gpu_addr, cpu_addr); const ImageBase new_image_base(new_info, gpu_addr, cpu_addr);
if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views)) { if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views, native_bgr)) {
left_aliased_ids.push_back(overlap_id); left_aliased_ids.push_back(overlap_id);
} else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options, } else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options,
broken_views)) { broken_views, native_bgr)) {
right_aliased_ids.push_back(overlap_id); right_aliased_ids.push_back(overlap_id);
} }
}); });

13
src/video_core/texture_cache/util.cpp
View file

@ -1025,13 +1025,13 @@ bool IsPitchLinearSameSize(const ImageInfo& lhs, const ImageInfo& rhs, bool stri
std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info, GPUVAddr gpu_addr, std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info, GPUVAddr gpu_addr,
VAddr cpu_addr, const ImageBase& overlap, VAddr cpu_addr, const ImageBase& overlap,
bool strict_size, bool broken_views) { bool strict_size, bool broken_views, bool native_bgr) {
ASSERT(new_info.type != ImageType::Linear); ASSERT(new_info.type != ImageType::Linear);
ASSERT(overlap.info.type != ImageType::Linear); ASSERT(overlap.info.type != ImageType::Linear);
if (!IsLayerStrideCompatible(new_info, overlap.info)) { if (!IsLayerStrideCompatible(new_info, overlap.info)) {
return std::nullopt; return std::nullopt;
} }
if (!IsViewCompatible(overlap.info.format, new_info.format, broken_views)) { if (!IsViewCompatible(overlap.info.format, new_info.format, broken_views, native_bgr)) {
return std::nullopt; return std::nullopt;
} }
if (gpu_addr == overlap.gpu_addr) { if (gpu_addr == overlap.gpu_addr) {
@ -1075,14 +1075,14 @@ bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs) {
std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const ImageBase& image, std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const ImageBase& image,
GPUVAddr candidate_addr, RelaxedOptions options, GPUVAddr candidate_addr, RelaxedOptions options,
bool broken_views) { bool broken_views, bool native_bgr) {
const std::optional<SubresourceBase> base = image.TryFindBase(candidate_addr); const std::optional<SubresourceBase> base = image.TryFindBase(candidate_addr);
if (!base) { if (!base) {
return std::nullopt; return std::nullopt;
} }
const ImageInfo& existing = image.info; const ImageInfo& existing = image.info;
if (False(options & RelaxedOptions::Format)) { if (False(options & RelaxedOptions::Format)) {
if (!IsViewCompatible(existing.format, candidate.format, broken_views)) { if (!IsViewCompatible(existing.format, candidate.format, broken_views, native_bgr)) {
return std::nullopt; return std::nullopt;
} }
} }
@ -1119,8 +1119,9 @@ std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const
} }
bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr candidate_addr, bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr candidate_addr,
RelaxedOptions options, bool broken_views) { RelaxedOptions options, bool broken_views, bool native_bgr) {
return FindSubresource(candidate, image, candidate_addr, options, broken_views).has_value(); return FindSubresource(candidate, image, candidate_addr, options, broken_views, native_bgr)
.has_value();
} }
void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst, void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,

9
src/video_core/texture_cache/util.h
View file

@ -87,7 +87,8 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
[[nodiscard]] std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info, [[nodiscard]] std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info,
GPUVAddr gpu_addr, VAddr cpu_addr, GPUVAddr gpu_addr, VAddr cpu_addr,
const ImageBase& overlap, const ImageBase& overlap,
bool strict_size, bool broken_views); bool strict_size, bool broken_views,
bool native_bgr);
[[nodiscard]] bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs); [[nodiscard]] bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs);
@ -95,11 +96,11 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
const ImageBase& image, const ImageBase& image,
GPUVAddr candidate_addr, GPUVAddr candidate_addr,
RelaxedOptions options, RelaxedOptions options,
bool broken_views); bool broken_views, bool native_bgr);
[[nodiscard]] bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, [[nodiscard]] bool IsSubresource(const ImageInfo& candidate, const ImageBase& image,
GPUVAddr candidate_addr, RelaxedOptions options, GPUVAddr candidate_addr, RelaxedOptions options, bool broken_views,
bool broken_views); bool native_bgr);
void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst, void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
const ImageBase* src); const ImageBase* src);

133
src/video_core/textures/astc.h
View file

@ -9,7 +9,7 @@
namespace Tegra::Texture::ASTC { namespace Tegra::Texture::ASTC {
enum class IntegerEncoding { JustBits, Qus32, Trit }; enum class IntegerEncoding { JustBits, Quint, Trit };
struct IntegerEncodedValue { struct IntegerEncodedValue {
constexpr IntegerEncodedValue() = default; constexpr IntegerEncodedValue() = default;
@ -21,50 +21,50 @@ struct IntegerEncodedValue {
return encoding == other.encoding && num_bits == other.num_bits; return encoding == other.encoding && num_bits == other.num_bits;
} }
// Returns the number of bits required to encode nVals values. // Returns the number of bits required to encode num_vals values.
u32 GetBitLength(u32 nVals) const { u32 GetBitLength(u32 num_vals) const {
u32 totalBits = num_bits * nVals; u32 total_bits = num_bits * num_vals;
if (encoding == IntegerEncoding::Trit) { if (encoding == IntegerEncoding::Trit) {
totalBits += (nVals * 8 + 4) / 5; total_bits += (num_vals * 8 + 4) / 5;
} else if (encoding == IntegerEncoding::Qus32) { } else if (encoding == IntegerEncoding::Quint) {
totalBits += (nVals * 7 + 2) / 3; total_bits += (num_vals * 7 + 2) / 3;
} }
return totalBits; return total_bits;
} }
IntegerEncoding encoding{}; IntegerEncoding encoding{};
u32 num_bits = 0; u32 num_bits = 0;
u32 bit_value = 0; u32 bit_value = 0;
union { union {
u32 qus32_value = 0; u32 quint_value = 0;
u32 trit_value; u32 trit_value;
}; };
}; };
// Returns a new instance of this struct that corresponds to the // Returns a new instance of this struct that corresponds to the
// can take no more than maxval values // can take no more than mav_value values
constexpr IntegerEncodedValue CreateEncoding(u32 maxVal) { constexpr IntegerEncodedValue CreateEncoding(u32 mav_value) {
while (maxVal > 0) { while (mav_value > 0) {
u32 check = maxVal + 1; u32 check = mav_value + 1;
// Is maxVal a power of two? // Is mav_value a power of two?
if (!(check & (check - 1))) { if (!(check & (check - 1))) {
return IntegerEncodedValue(IntegerEncoding::JustBits, std::popcount(maxVal)); return IntegerEncodedValue(IntegerEncoding::JustBits, std::popcount(mav_value));
} }
// Is maxVal of the type 3*2^n - 1? // Is mav_value of the type 3*2^n - 1?
if ((check % 3 == 0) && !((check / 3) & ((check / 3) - 1))) { if ((check % 3 == 0) && !((check / 3) & ((check / 3) - 1))) {
return IntegerEncodedValue(IntegerEncoding::Trit, std::popcount(check / 3 - 1)); return IntegerEncodedValue(IntegerEncoding::Trit, std::popcount(check / 3 - 1));
} }
// Is maxVal of the type 5*2^n - 1? // Is mav_value of the type 5*2^n - 1?
if ((check % 5 == 0) && !((check / 5) & ((check / 5) - 1))) { if ((check % 5 == 0) && !((check / 5) & ((check / 5) - 1))) {
return IntegerEncodedValue(IntegerEncoding::Qus32, std::popcount(check / 5 - 1)); return IntegerEncodedValue(IntegerEncoding::Quint, std::popcount(check / 5 - 1));
} }
// Apparently it can't be represented with a bounded integer sequence... // Apparently it can't be represented with a bounded integer sequence...
// just iterate. // just iterate.
maxVal--; mav_value--;
} }
return IntegerEncodedValue(IntegerEncoding::JustBits, 0); return IntegerEncodedValue(IntegerEncoding::JustBits, 0);
} }
@ -79,29 +79,26 @@ constexpr std::array<IntegerEncodedValue, 256> MakeEncodedValues() {
constexpr std::array<IntegerEncodedValue, 256> EncodingsValues = MakeEncodedValues(); constexpr std::array<IntegerEncodedValue, 256> EncodingsValues = MakeEncodedValues();
// Replicates low numBits such that [(toBit - 1):(toBit - 1 - fromBit)] // Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)]
// is the same as [(numBits - 1):0] and repeats all the way down. // is the same as [(num_bits - 1):0] and repeats all the way down.
template <typename IntType> template <typename IntType>
constexpr IntType Replicate(IntType val, u32 numBits, u32 toBit) { constexpr IntType Replicate(IntType val, u32 num_bits, u32 to_bit) {
if (numBits == 0) { if (num_bits == 0 || to_bit == 0) {
return 0; return 0;
} }
if (toBit == 0) { const IntType v = val & static_cast<IntType>((1 << num_bits) - 1);
return 0;
}
const IntType v = val & static_cast<IntType>((1 << numBits) - 1);
IntType res = v; IntType res = v;
u32 reslen = numBits; u32 reslen = num_bits;
while (reslen < toBit) { while (reslen < to_bit) {
u32 comp = 0; u32 comp = 0;
if (numBits > toBit - reslen) { if (num_bits > to_bit - reslen) {
u32 newshift = toBit - reslen; u32 newshift = to_bit - reslen;
comp = numBits - newshift; comp = num_bits - newshift;
numBits = newshift; num_bits = newshift;
} }
res = static_cast<IntType>(res << numBits); res = static_cast<IntType>(res << num_bits);
res = static_cast<IntType>(res | (v >> comp)); res = static_cast<IntType>(res | (v >> comp));
reslen += numBits; reslen += num_bits;
} }
return res; return res;
} }
@ -120,75 +117,9 @@ constexpr auto MakeReplicateTable() {
} }
constexpr auto REPLICATE_BYTE_TO_16_TABLE = MakeReplicateTable<u32, 8, 16>(); constexpr auto REPLICATE_BYTE_TO_16_TABLE = MakeReplicateTable<u32, 8, 16>();
constexpr u32 ReplicateByteTo16(std::size_t value) {
return REPLICATE_BYTE_TO_16_TABLE[value];
}
constexpr auto REPLICATE_BIT_TO_7_TABLE = MakeReplicateTable<u32, 1, 7>();
constexpr u32 ReplicateBitTo7(std::size_t value) {
return REPLICATE_BIT_TO_7_TABLE[value];
}
constexpr auto REPLICATE_BIT_TO_9_TABLE = MakeReplicateTable<u32, 1, 9>();
constexpr u32 ReplicateBitTo9(std::size_t value) {
return REPLICATE_BIT_TO_9_TABLE[value];
}
constexpr auto REPLICATE_1_BIT_TO_8_TABLE = MakeReplicateTable<u32, 1, 8>();
constexpr auto REPLICATE_2_BIT_TO_8_TABLE = MakeReplicateTable<u32, 2, 8>();
constexpr auto REPLICATE_3_BIT_TO_8_TABLE = MakeReplicateTable<u32, 3, 8>();
constexpr auto REPLICATE_4_BIT_TO_8_TABLE = MakeReplicateTable<u32, 4, 8>();
constexpr auto REPLICATE_5_BIT_TO_8_TABLE = MakeReplicateTable<u32, 5, 8>();
constexpr auto REPLICATE_6_BIT_TO_8_TABLE = MakeReplicateTable<u32, 6, 8>(); constexpr auto REPLICATE_6_BIT_TO_8_TABLE = MakeReplicateTable<u32, 6, 8>();
constexpr auto REPLICATE_7_BIT_TO_8_TABLE = MakeReplicateTable<u32, 7, 8>(); constexpr auto REPLICATE_7_BIT_TO_8_TABLE = MakeReplicateTable<u32, 7, 8>();
constexpr auto REPLICATE_8_BIT_TO_8_TABLE = MakeReplicateTable<u32, 8, 8>(); constexpr auto REPLICATE_8_BIT_TO_8_TABLE = MakeReplicateTable<u32, 8, 8>();
/// Use a precompiled table with the most common usages, if it's not in the expected range, fallback
/// to the runtime implementation
constexpr u32 FastReplicateTo8(u32 value, u32 num_bits) {
switch (num_bits) {
case 1:
return REPLICATE_1_BIT_TO_8_TABLE[value];
case 2:
return REPLICATE_2_BIT_TO_8_TABLE[value];
case 3:
return REPLICATE_3_BIT_TO_8_TABLE[value];
case 4:
return REPLICATE_4_BIT_TO_8_TABLE[value];
case 5:
return REPLICATE_5_BIT_TO_8_TABLE[value];
case 6:
return REPLICATE_6_BIT_TO_8_TABLE[value];
case 7:
return REPLICATE_7_BIT_TO_8_TABLE[value];
case 8:
return REPLICATE_8_BIT_TO_8_TABLE[value];
default:
return Replicate(value, num_bits, 8);
}
}
constexpr auto REPLICATE_1_BIT_TO_6_TABLE = MakeReplicateTable<u32, 1, 6>();
constexpr auto REPLICATE_2_BIT_TO_6_TABLE = MakeReplicateTable<u32, 2, 6>();
constexpr auto REPLICATE_3_BIT_TO_6_TABLE = MakeReplicateTable<u32, 3, 6>();
constexpr auto REPLICATE_4_BIT_TO_6_TABLE = MakeReplicateTable<u32, 4, 6>();
constexpr auto REPLICATE_5_BIT_TO_6_TABLE = MakeReplicateTable<u32, 5, 6>();
constexpr u32 FastReplicateTo6(u32 value, u32 num_bits) {
switch (num_bits) {
case 1:
return REPLICATE_1_BIT_TO_6_TABLE[value];
case 2:
return REPLICATE_2_BIT_TO_6_TABLE[value];
case 3:
return REPLICATE_3_BIT_TO_6_TABLE[value];
case 4:
return REPLICATE_4_BIT_TO_6_TABLE[value];
case 5:
return REPLICATE_5_BIT_TO_6_TABLE[value];
default:
return Replicate(value, num_bits, 6);
}
}
struct AstcBufferData { struct AstcBufferData {
decltype(EncodingsValues) encoding_values = EncodingsValues; decltype(EncodingsValues) encoding_values = EncodingsValues;

25
src/yuzu/bootmanager.cpp
View file

@ -383,6 +383,25 @@ void GRenderWindow::keyReleaseEvent(QKeyEvent* event) {
input_subsystem->GetKeyboard()->ReleaseKey(event->key()); input_subsystem->GetKeyboard()->ReleaseKey(event->key());
} }
MouseInput::MouseButton GRenderWindow::QtButtonToMouseButton(Qt::MouseButton button) {
switch (button) {
case Qt::LeftButton:
return MouseInput::MouseButton::Left;
case Qt::RightButton:
return MouseInput::MouseButton::Right;
case Qt::MiddleButton:
return MouseInput::MouseButton::Wheel;
case Qt::BackButton:
return MouseInput::MouseButton::Backward;
case Qt::ForwardButton:
return MouseInput::MouseButton::Forward;
case Qt::TaskButton:
return MouseInput::MouseButton::Task;
default:
return MouseInput::MouseButton::Extra;
}
}
void GRenderWindow::mousePressEvent(QMouseEvent* event) { void GRenderWindow::mousePressEvent(QMouseEvent* event) {
// Touch input is handled in TouchBeginEvent // Touch input is handled in TouchBeginEvent
if (event->source() == Qt::MouseEventSynthesizedBySystem) { if (event->source() == Qt::MouseEventSynthesizedBySystem) {
@ -391,7 +410,8 @@ void GRenderWindow::mousePressEvent(QMouseEvent* event) {
auto pos = event->pos(); auto pos = event->pos();
const auto [x, y] = ScaleTouch(pos); const auto [x, y] = ScaleTouch(pos);
input_subsystem->GetMouse()->PressButton(x, y, event->button()); const auto button = QtButtonToMouseButton(event->button());
input_subsystem->GetMouse()->PressButton(x, y, button);
if (event->button() == Qt::LeftButton) { if (event->button() == Qt::LeftButton) {
this->TouchPressed(x, y, 0); this->TouchPressed(x, y, 0);
@ -425,7 +445,8 @@ void GRenderWindow::mouseReleaseEvent(QMouseEvent* event) {
return; return;
} }
input_subsystem->GetMouse()->ReleaseButton(event->button()); const auto button = QtButtonToMouseButton(event->button());
input_subsystem->GetMouse()->ReleaseButton(button);
if (event->button() == Qt::LeftButton) { if (event->button() == Qt::LeftButton) {
this->TouchReleased(0); this->TouchReleased(0);

7
src/yuzu/bootmanager.h
View file

@ -28,6 +28,10 @@ namespace InputCommon {
class InputSubsystem; class InputSubsystem;
} }
namespace MouseInput {
enum class MouseButton;
}
namespace VideoCore { namespace VideoCore {
enum class LoadCallbackStage; enum class LoadCallbackStage;
} }
@ -149,6 +153,9 @@ public:
void keyPressEvent(QKeyEvent* event) override; void keyPressEvent(QKeyEvent* event) override;
void keyReleaseEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override;
/// Converts a Qt mouse button into MouseInput mouse button
static MouseInput::MouseButton QtButtonToMouseButton(Qt::MouseButton button);
void mousePressEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override;
void mouseMoveEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent* event) override; void mouseReleaseEvent(QMouseEvent* event) override;

5
src/yuzu/configuration/config.cpp
View file

@ -235,7 +235,7 @@ const std::array<UISettings::Shortcut, 17> Config::default_hotkeys{{
{QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}}, {QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
{QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}}, {QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}}, {QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("F9"), Qt::ApplicationShortcut}}, {QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}}, {QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}}, {QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
}}; }};
@ -508,7 +508,7 @@ void Config::ReadControlValues() {
Settings::values.emulate_analog_keyboard = Settings::values.emulate_analog_keyboard =
ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool(); ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool();
Settings::values.mouse_panning = ReadSetting(QStringLiteral("mouse_panning"), false).toBool(); Settings::values.mouse_panning = false;
Settings::values.mouse_panning_sensitivity = Settings::values.mouse_panning_sensitivity =
ReadSetting(QStringLiteral("mouse_panning_sensitivity"), 1).toFloat(); ReadSetting(QStringLiteral("mouse_panning_sensitivity"), 1).toFloat();
@ -1182,7 +1182,6 @@ void Config::SaveControlValues() {
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false); WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false);
WriteSetting(QStringLiteral("emulate_analog_keyboard"), WriteSetting(QStringLiteral("emulate_analog_keyboard"),
Settings::values.emulate_analog_keyboard, false); Settings::values.emulate_analog_keyboard, false);
WriteSetting(QStringLiteral("mouse_panning"), Settings::values.mouse_panning, false);
WriteSetting(QStringLiteral("mouse_panning_sensitivity"), WriteSetting(QStringLiteral("mouse_panning_sensitivity"),
Settings::values.mouse_panning_sensitivity, 1.0f); Settings::values.mouse_panning_sensitivity, 1.0f);
qt_config->endGroup(); qt_config->endGroup();

4
src/yuzu/configuration/configure_input_player.cpp
View file

@ -21,6 +21,7 @@
#include "input_common/mouse/mouse_poller.h" #include "input_common/mouse/mouse_poller.h"
#include "input_common/udp/udp.h" #include "input_common/udp/udp.h"
#include "ui_configure_input_player.h" #include "ui_configure_input_player.h"
#include "yuzu/bootmanager.h"
#include "yuzu/configuration/config.h" #include "yuzu/configuration/config.h"
#include "yuzu/configuration/configure_input_player.h" #include "yuzu/configuration/configure_input_player.h"
#include "yuzu/configuration/configure_input_player_widget.h" #include "yuzu/configuration/configure_input_player_widget.h"
@ -1345,7 +1346,8 @@ void ConfigureInputPlayer::mousePressEvent(QMouseEvent* event) {
return; return;
} }
input_subsystem->GetMouse()->PressButton(0, 0, event->button()); const auto button = GRenderWindow::QtButtonToMouseButton(event->button());
input_subsystem->GetMouse()->PressButton(0, 0, button);
} }
void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) { void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {

19
src/yuzu/main.cpp
View file

@ -854,8 +854,7 @@ void GMainWindow::InitializeHotkeys() {
connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Mouse Panning"), this), connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Mouse Panning"), this),
&QShortcut::activated, this, [&] { &QShortcut::activated, this, [&] {
Settings::values.mouse_panning = !Settings::values.mouse_panning; Settings::values.mouse_panning = !Settings::values.mouse_panning;
if (UISettings::values.hide_mouse || Settings::values.mouse_panning) { if (Settings::values.mouse_panning) {
mouse_hide_timer.start();
render_window->installEventFilter(render_window); render_window->installEventFilter(render_window);
render_window->setAttribute(Qt::WA_Hover, true); render_window->setAttribute(Qt::WA_Hover, true);
} }
@ -1208,11 +1207,14 @@ void GMainWindow::BootGame(const QString& filename, std::size_t program_index) {
renderer_status_button->setDisabled(true); renderer_status_button->setDisabled(true);
if (UISettings::values.hide_mouse || Settings::values.mouse_panning) { if (UISettings::values.hide_mouse || Settings::values.mouse_panning) {
mouse_hide_timer.start();
render_window->installEventFilter(render_window); render_window->installEventFilter(render_window);
render_window->setAttribute(Qt::WA_Hover, true); render_window->setAttribute(Qt::WA_Hover, true);
} }
if (UISettings::values.hide_mouse) {
mouse_hide_timer.start();
}
std::string title_name; std::string title_name;
std::string title_version; std::string title_version;
const auto res = system.GetGameName(title_name); const auto res = system.GetGameName(title_name);
@ -2372,12 +2374,15 @@ void GMainWindow::OnConfigure() {
if ((UISettings::values.hide_mouse || Settings::values.mouse_panning) && emulation_running) { if ((UISettings::values.hide_mouse || Settings::values.mouse_panning) && emulation_running) {
render_window->installEventFilter(render_window); render_window->installEventFilter(render_window);
render_window->setAttribute(Qt::WA_Hover, true); render_window->setAttribute(Qt::WA_Hover, true);
mouse_hide_timer.start();
} else { } else {
render_window->removeEventFilter(render_window); render_window->removeEventFilter(render_window);
render_window->setAttribute(Qt::WA_Hover, false); render_window->setAttribute(Qt::WA_Hover, false);
} }
if (UISettings::values.hide_mouse) {
mouse_hide_timer.start();
}
UpdateStatusButtons(); UpdateStatusButtons();
} }
@ -2615,8 +2620,7 @@ void GMainWindow::UpdateUISettings() {
} }
void GMainWindow::HideMouseCursor() { void GMainWindow::HideMouseCursor() {
if (emu_thread == nullptr || if (emu_thread == nullptr && UISettings::values.hide_mouse) {
(!UISettings::values.hide_mouse && !Settings::values.mouse_panning)) {
mouse_hide_timer.stop(); mouse_hide_timer.stop();
ShowMouseCursor(); ShowMouseCursor();
return; return;
@ -2626,8 +2630,7 @@ void GMainWindow::HideMouseCursor() {
void GMainWindow::ShowMouseCursor() { void GMainWindow::ShowMouseCursor() {
render_window->unsetCursor(); render_window->unsetCursor();
if (emu_thread != nullptr && if (emu_thread != nullptr && UISettings::values.hide_mouse) {
(UISettings::values.hide_mouse || Settings::values.mouse_panning)) {
mouse_hide_timer.start(); mouse_hide_timer.start();
} }
} }

26
src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
View file

@ -35,18 +35,36 @@ void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
input_subsystem->GetMouse()->MouseMove(x, y, 0, 0); input_subsystem->GetMouse()->MouseMove(x, y, 0, 0);
} }
MouseInput::MouseButton EmuWindow_SDL2::SDLButtonToMouseButton(u32 button) const {
switch (button) {
case SDL_BUTTON_LEFT:
return MouseInput::MouseButton::Left;
case SDL_BUTTON_RIGHT:
return MouseInput::MouseButton::Right;
case SDL_BUTTON_MIDDLE:
return MouseInput::MouseButton::Wheel;
case SDL_BUTTON_X1:
return MouseInput::MouseButton::Backward;
case SDL_BUTTON_X2:
return MouseInput::MouseButton::Forward;
default:
return MouseInput::MouseButton::Undefined;
}
}
void EmuWindow_SDL2::OnMouseButton(u32 button, u8 state, s32 x, s32 y) { void EmuWindow_SDL2::OnMouseButton(u32 button, u8 state, s32 x, s32 y) {
const auto mouse_button = SDLButtonToMouseButton(button);
if (button == SDL_BUTTON_LEFT) { if (button == SDL_BUTTON_LEFT) {
if (state == SDL_PRESSED) { if (state == SDL_PRESSED) {
TouchPressed((unsigned)std::max(x, 0), (unsigned)std::max(y, 0), 0); TouchPressed((unsigned)std::max(x, 0), (unsigned)std::max(y, 0), 0);
} else { } else {
TouchReleased(0); TouchReleased(0);
} }
} else if (button == SDL_BUTTON_RIGHT) {
if (state == SDL_PRESSED) {
input_subsystem->GetMouse()->PressButton(x, y, button);
} else { } else {
input_subsystem->GetMouse()->ReleaseButton(button); if (state == SDL_PRESSED) {
input_subsystem->GetMouse()->PressButton(x, y, mouse_button);
} else {
input_subsystem->GetMouse()->ReleaseButton(mouse_button);
} }
} }
} }

7
src/yuzu_cmd/emu_window/emu_window_sdl2.h
View file

@ -18,6 +18,10 @@ namespace InputCommon {
class InputSubsystem; class InputSubsystem;
} }
namespace MouseInput {
enum class MouseButton;
}
class EmuWindow_SDL2 : public Core::Frontend::EmuWindow { class EmuWindow_SDL2 : public Core::Frontend::EmuWindow {
public: public:
explicit EmuWindow_SDL2(InputCommon::InputSubsystem* input_subsystem); explicit EmuWindow_SDL2(InputCommon::InputSubsystem* input_subsystem);
@ -42,6 +46,9 @@ protected:
/// Called by WaitEvent when the mouse moves. /// Called by WaitEvent when the mouse moves.
void OnMouseMotion(s32 x, s32 y); void OnMouseMotion(s32 x, s32 y);
/// Converts a SDL mouse button into MouseInput mouse button
MouseInput::MouseButton SDLButtonToMouseButton(u32 button) const;
/// Called by WaitEvent when a mouse button is pressed or released /// Called by WaitEvent when a mouse button is pressed or released
void OnMouseButton(u32 button, u8 state, s32 x, s32 y); void OnMouseButton(u32 button, u8 state, s32 x, s32 y);