Exverge/suyu
3
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity
suyu/src/video_core/gpu_synch.cpp

46 lines
1.1 KiB
C++
Raw Normal View History

gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
// Copyright 2019 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "video_core/gpu_synch.h"
#include "video_core/renderer_base.h"
namespace VideoCommon {
video_core: Initialize renderer with a GPU Add an extra step in GPU initialization to be able to initialize render backends with a valid GPU instance.
2020-06-11 05:58:57 +02:00
GPUSynch::GPUSynch(Core::System& system) : GPU{system, false} {}
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
GPUSynch::~GPUSynch() = default;
General: Correct rebase, sync gpu and context management.
2020-04-03 17:58:43 +02:00
void GPUSynch::Start() {}
void GPUSynch::ObtainContext() {
video_core: Initialize renderer with a GPU Add an extra step in GPU initialization to be able to initialize render backends with a valid GPU instance.
2020-06-11 05:58:57 +02:00
renderer->Context().MakeCurrent();
Frontend/GPU: Refactor context management Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
2020-03-25 03:58:49 +01:00
}
video_core/gpu: Create threads separately from initialization Like with CPU emulation, we generally don't want to fire off the threads immediately after the relevant classes are initialized, we want to do this after all necessary data is done loading first. This splits the thread creation into its own interface member function to allow controlling when these threads in particular get created.
2019-04-09 20:02:00 +02:00
General: Correct rebase, sync gpu and context management.
2020-04-03 17:58:43 +02:00
void GPUSynch::ReleaseContext() {
video_core: Initialize renderer with a GPU Add an extra step in GPU initialization to be able to initialize render backends with a valid GPU instance.
2020-06-11 05:58:57 +02:00
renderer->Context().DoneCurrent();
General: Correct rebase, sync gpu and context management.
2020-04-03 17:58:43 +02:00
}
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
void GPUSynch::PushGPUEntries(Tegra::CommandList&& entries) {
dma_pusher->Push(std::move(entries));
dma_pusher->DispatchCalls();
}
gpu: Change optional<reference_wrapper<T>> to T* for FramebufferConfig
2019-08-21 06:55:25 +02:00
void GPUSynch::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
Frontend/GPU: Refactor context management Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
2020-03-25 03:58:49 +01:00
renderer->SwapBuffers(framebuffer);
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
}
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void GPUSynch::FlushRegion(VAddr addr, u64 size) {
Frontend/GPU: Refactor context management Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
2020-03-25 03:58:49 +01:00
renderer->Rasterizer().FlushRegion(addr, size);
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
}
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void GPUSynch::InvalidateRegion(VAddr addr, u64 size) {
Frontend/GPU: Refactor context management Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
2020-03-25 03:58:49 +01:00
renderer->Rasterizer().InvalidateRegion(addr, size);
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
}
GPU: Setup Flush/Invalidate to use VAddr instead of CacheAddr
2020-04-05 18:58:23 +02:00
void GPUSynch::FlushAndInvalidateRegion(VAddr addr, u64 size) {
Frontend/GPU: Refactor context management Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
2020-03-25 03:58:49 +01:00
renderer->Rasterizer().FlushAndInvalidateRegion(addr, size);
gpu: Refactor a/synchronous implementations into their own classes.
2019-02-09 05:21:53 +01:00
}
} // namespace VideoCommon
Copy permalink