2018-03-20 06:00:59 +03:00
|
|
|
// Copyright 2018 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2019-01-20 07:03:26 +03:00
|
|
|
#include <functional>
|
2019-11-28 08:15:34 +03:00
|
|
|
#include <optional>
|
2021-01-17 02:48:58 +03:00
|
|
|
#include <span>
|
2021-06-22 06:04:55 +03:00
|
|
|
#include <stop_token>
|
2018-03-20 06:00:59 +03:00
|
|
|
#include "common/common_types.h"
|
2018-10-06 06:39:03 +03:00
|
|
|
#include "video_core/engines/fermi_2d.h"
|
2018-03-23 04:04:30 +03:00
|
|
|
#include "video_core/gpu.h"
|
2020-01-03 23:16:29 +03:00
|
|
|
#include "video_core/guest_driver.h"
|
2018-03-20 06:00:59 +03:00
|
|
|
|
2019-05-07 17:55:18 +03:00
|
|
|
namespace Tegra {
|
|
|
|
class MemoryManager;
|
|
|
|
}
|
|
|
|
|
2018-03-20 06:00:59 +03:00
|
|
|
namespace VideoCore {
|
|
|
|
|
2019-07-28 01:40:10 +03:00
|
|
|
enum class QueryType {
|
|
|
|
SamplesPassed,
|
|
|
|
};
|
2019-11-27 00:52:15 +03:00
|
|
|
constexpr std::size_t NumQueryTypes = 1;
|
2019-07-28 01:40:10 +03:00
|
|
|
|
2019-01-20 07:03:26 +03:00
|
|
|
enum class LoadCallbackStage {
|
|
|
|
Prepare,
|
2019-01-21 04:40:25 +03:00
|
|
|
Build,
|
2019-01-20 07:03:26 +03:00
|
|
|
Complete,
|
|
|
|
};
|
|
|
|
using DiskResourceLoadCallback = std::function<void(LoadCallbackStage, std::size_t, std::size_t)>;
|
|
|
|
|
2018-03-20 06:00:59 +03:00
|
|
|
class RasterizerInterface {
|
|
|
|
public:
|
2020-11-17 15:17:43 +03:00
|
|
|
virtual ~RasterizerInterface() = default;
|
2018-03-20 06:00:59 +03:00
|
|
|
|
2020-02-15 00:09:37 +03:00
|
|
|
/// Dispatches a draw invocation
|
|
|
|
virtual void Draw(bool is_indexed, bool is_instanced) = 0;
|
2019-09-15 18:48:54 +03:00
|
|
|
|
2018-06-07 07:54:25 +03:00
|
|
|
/// Clear the current framebuffer
|
|
|
|
virtual void Clear() = 0;
|
|
|
|
|
2019-07-15 04:25:13 +03:00
|
|
|
/// Dispatches a compute shader invocation
|
|
|
|
virtual void DispatchCompute(GPUVAddr code_addr) = 0;
|
|
|
|
|
2019-07-28 01:40:10 +03:00
|
|
|
/// Resets the counter of a query
|
|
|
|
virtual void ResetCounter(QueryType type) = 0;
|
|
|
|
|
2019-11-27 00:52:15 +03:00
|
|
|
/// Records a GPU query and caches it
|
2019-11-28 08:15:34 +03:00
|
|
|
virtual void Query(GPUVAddr gpu_addr, QueryType type, std::optional<u64> timestamp) = 0;
|
2019-07-28 01:40:10 +03:00
|
|
|
|
2021-01-17 02:48:58 +03:00
|
|
|
/// Signal an uniform buffer binding
|
|
|
|
virtual void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr,
|
|
|
|
u32 size) = 0;
|
|
|
|
|
2021-06-01 20:26:43 +03:00
|
|
|
/// Signal disabling of a uniform buffer
|
|
|
|
virtual void DisableGraphicsUniformBuffer(size_t stage, u32 index) = 0;
|
|
|
|
|
2020-02-19 20:40:37 +03:00
|
|
|
/// Signal a GPU based semaphore as a fence
|
|
|
|
virtual void SignalSemaphore(GPUVAddr addr, u32 value) = 0;
|
|
|
|
|
|
|
|
/// Signal a GPU based syncpoint as a fence
|
|
|
|
virtual void SignalSyncPoint(u32 value) = 0;
|
2020-02-18 01:10:23 +03:00
|
|
|
|
2020-02-18 20:24:38 +03:00
|
|
|
/// Release all pending fences.
|
|
|
|
virtual void ReleaseFences() = 0;
|
2020-02-18 01:10:23 +03:00
|
|
|
|
2018-04-05 00:07:58 +03:00
|
|
|
/// Notify rasterizer that all caches should be flushed to Switch memory
|
2018-03-20 06:00:59 +03:00
|
|
|
virtual void FlushAll() = 0;
|
|
|
|
|
2018-04-05 00:07:58 +03:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2020-04-05 19:58:23 +03:00
|
|
|
virtual void FlushRegion(VAddr addr, u64 size) = 0;
|
2018-03-20 06:00:59 +03:00
|
|
|
|
2020-04-16 19:29:53 +03:00
|
|
|
/// Check if the the specified memory area requires flushing to CPU Memory.
|
2020-02-18 05:29:04 +03:00
|
|
|
virtual bool MustFlushRegion(VAddr addr, u64 size) = 0;
|
|
|
|
|
2018-03-20 06:00:59 +03:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be invalidated
|
2020-04-05 19:58:23 +03:00
|
|
|
virtual void InvalidateRegion(VAddr addr, u64 size) = 0;
|
2018-03-20 06:00:59 +03:00
|
|
|
|
2020-02-16 16:51:37 +03:00
|
|
|
/// Notify rasterizer that any caches of the specified region are desync with guest
|
|
|
|
virtual void OnCPUWrite(VAddr addr, u64 size) = 0;
|
|
|
|
|
|
|
|
/// Sync memory between guest and host.
|
|
|
|
virtual void SyncGuestHost() = 0;
|
|
|
|
|
2020-12-30 08:25:23 +03:00
|
|
|
/// Unmap memory range
|
|
|
|
virtual void UnmapMemory(VAddr addr, u64 size) = 0;
|
|
|
|
|
2021-06-12 16:52:27 +03:00
|
|
|
/// Unmap memory range
|
|
|
|
virtual void ModifyGPUMemory(GPUVAddr addr, u64 size) = 0;
|
|
|
|
|
2018-04-05 00:07:58 +03:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2018-03-20 06:00:59 +03:00
|
|
|
/// and invalidated
|
2020-04-05 19:58:23 +03:00
|
|
|
virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
|
2018-03-20 06:00:59 +03:00
|
|
|
|
2020-04-28 08:14:11 +03:00
|
|
|
/// Notify the host renderer to wait for previous primitive and compute operations.
|
|
|
|
virtual void WaitForIdle() = 0;
|
|
|
|
|
2020-12-30 08:25:23 +03:00
|
|
|
/// Notify the host renderer to wait for reads and writes to render targets and flush caches.
|
|
|
|
virtual void FragmentBarrier() = 0;
|
|
|
|
|
|
|
|
/// Notify the host renderer to make available previous render target writes.
|
|
|
|
virtual void TiledCacheBarrier() = 0;
|
|
|
|
|
2019-08-30 21:08:00 +03:00
|
|
|
/// Notify the rasterizer to send all written commands to the host GPU.
|
2019-07-26 21:20:43 +03:00
|
|
|
virtual void FlushCommands() = 0;
|
|
|
|
|
2019-06-20 09:22:25 +03:00
|
|
|
/// Notify rasterizer that a frame is about to finish
|
|
|
|
virtual void TickFrame() = 0;
|
|
|
|
|
2018-10-06 06:39:03 +03:00
|
|
|
/// Attempt to use a faster method to perform a surface copy
|
2020-11-17 15:17:43 +03:00
|
|
|
[[nodiscard]] virtual bool AccelerateSurfaceCopy(
|
2020-12-30 08:25:23 +03:00
|
|
|
const Tegra::Engines::Fermi2D::Surface& src, const Tegra::Engines::Fermi2D::Surface& dst,
|
2020-11-17 15:17:43 +03:00
|
|
|
const Tegra::Engines::Fermi2D::Config& copy_config) {
|
2018-03-20 06:00:59 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Attempt to use a faster method to display the framebuffer to screen
|
2020-11-17 15:17:43 +03:00
|
|
|
[[nodiscard]] virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config,
|
|
|
|
VAddr framebuffer_addr, u32 pixel_stride) {
|
2018-03-20 06:00:59 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-08-29 01:43:08 +03:00
|
|
|
/// Increase/decrease the number of object in pages touching the specified region
|
2019-02-19 04:58:32 +03:00
|
|
|
virtual void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {}
|
2019-01-14 04:05:53 +03:00
|
|
|
|
|
|
|
/// Initialize disk cached resources for the game being emulated
|
2021-06-22 06:04:55 +03:00
|
|
|
virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
|
2020-06-12 03:24:45 +03:00
|
|
|
const DiskResourceLoadCallback& callback) {}
|
2019-12-27 04:14:10 +03:00
|
|
|
|
2020-01-08 18:46:36 +03:00
|
|
|
/// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver.
|
2020-11-17 15:17:43 +03:00
|
|
|
[[nodiscard]] GuestDriverProfile& AccessGuestDriverProfile() {
|
2020-01-03 23:16:29 +03:00
|
|
|
return guest_driver_profile;
|
|
|
|
}
|
|
|
|
|
2020-01-08 18:46:36 +03:00
|
|
|
/// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver.
|
2020-11-17 15:17:43 +03:00
|
|
|
[[nodiscard]] const GuestDriverProfile& AccessGuestDriverProfile() const {
|
2020-01-08 17:28:29 +03:00
|
|
|
return guest_driver_profile;
|
|
|
|
}
|
|
|
|
|
2020-01-03 23:16:29 +03:00
|
|
|
private:
|
|
|
|
GuestDriverProfile guest_driver_profile{};
|
2018-03-20 06:00:59 +03:00
|
|
|
};
|
|
|
|
} // namespace VideoCore
|