2022-04-23 03:59:50 -05:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2018-03-19 22:00:59 -05:00
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2019-01-19 22:03:26 -06:00
|
|
|
#include <functional>
|
2019-11-27 23:15:34 -06:00
|
|
|
#include <optional>
|
2021-01-16 17:48:58 -06:00
|
|
|
#include <span>
|
2023-01-04 21:05:20 -06:00
|
|
|
#include <utility>
|
2018-03-19 22:00:59 -05:00
|
|
|
#include "common/common_types.h"
|
2022-11-21 10:31:18 -06:00
|
|
|
#include "common/polyfill_thread.h"
|
2022-11-19 20:07:14 -06:00
|
|
|
#include "video_core/cache_types.h"
|
2018-10-05 22:39:03 -05:00
|
|
|
#include "video_core/engines/fermi_2d.h"
|
2018-03-22 20:04:30 -05:00
|
|
|
#include "video_core/gpu.h"
|
2023-08-06 02:38:16 -05:00
|
|
|
#include "video_core/query_cache/types.h"
|
2023-04-30 10:14:06 -05:00
|
|
|
#include "video_core/rasterizer_download_area.h"
|
2018-03-19 22:00:59 -05:00
|
|
|
|
2019-05-07 09:55:18 -05:00
|
|
|
namespace Tegra {
|
|
|
|
class MemoryManager;
|
2021-07-11 21:10:42 -05:00
|
|
|
namespace Engines {
|
|
|
|
class AccelerateDMAInterface;
|
2019-05-07 09:55:18 -05:00
|
|
|
}
|
2021-11-05 09:52:31 -05:00
|
|
|
namespace Control {
|
|
|
|
struct ChannelState;
|
|
|
|
}
|
2021-07-11 21:10:42 -05:00
|
|
|
} // namespace Tegra
|
2019-05-07 09:55:18 -05:00
|
|
|
|
2018-03-19 22:00:59 -05:00
|
|
|
namespace VideoCore {
|
|
|
|
|
2019-01-19 22:03:26 -06:00
|
|
|
enum class LoadCallbackStage {
|
|
|
|
Prepare,
|
2019-01-20 19:40:25 -06:00
|
|
|
Build,
|
2019-01-19 22:03:26 -06:00
|
|
|
Complete,
|
|
|
|
};
|
|
|
|
using DiskResourceLoadCallback = std::function<void(LoadCallbackStage, std::size_t, std::size_t)>;
|
|
|
|
|
2018-03-19 22:00:59 -05:00
|
|
|
class RasterizerInterface {
|
|
|
|
public:
|
2020-11-17 06:17:43 -06:00
|
|
|
virtual ~RasterizerInterface() = default;
|
2018-03-19 22:00:59 -05:00
|
|
|
|
2020-02-14 15:09:37 -06:00
|
|
|
/// Dispatches a draw invocation
|
2022-10-21 02:38:50 -05:00
|
|
|
virtual void Draw(bool is_indexed, u32 instance_count) = 0;
|
2019-09-15 10:48:54 -05:00
|
|
|
|
2022-02-09 08:00:05 -06:00
|
|
|
/// Dispatches an indirect draw invocation
|
2022-02-09 08:39:40 -06:00
|
|
|
virtual void DrawIndirect() {}
|
2022-02-09 08:00:05 -06:00
|
|
|
|
2023-01-04 22:28:48 -06:00
|
|
|
/// Dispatches an draw texture invocation
|
|
|
|
virtual void DrawTexture() = 0;
|
|
|
|
|
2018-06-06 23:54:25 -05:00
|
|
|
/// Clear the current framebuffer
|
2022-11-16 21:41:40 -06:00
|
|
|
virtual void Clear(u32 layer_count) = 0;
|
2018-06-06 23:54:25 -05:00
|
|
|
|
2019-07-14 20:25:13 -05:00
|
|
|
/// Dispatches a compute shader invocation
|
2021-02-16 17:52:12 -06:00
|
|
|
virtual void DispatchCompute() = 0;
|
2019-07-14 20:25:13 -05:00
|
|
|
|
2019-07-27 17:40:10 -05:00
|
|
|
/// Resets the counter of a query
|
2023-08-03 20:32:30 -05:00
|
|
|
virtual void ResetCounter(VideoCommon::QueryType type) = 0;
|
2019-07-27 17:40:10 -05:00
|
|
|
|
2019-11-26 15:52:15 -06:00
|
|
|
/// Records a GPU query and caches it
|
2023-08-06 02:38:16 -05:00
|
|
|
virtual void Query(GPUVAddr gpu_addr, VideoCommon::QueryType type,
|
|
|
|
VideoCommon::QueryPropertiesFlags flags, u32 payload, u32 subreport) = 0;
|
2019-07-27 17:40:10 -05:00
|
|
|
|
2021-01-16 17:48:58 -06:00
|
|
|
/// Signal an uniform buffer binding
|
|
|
|
virtual void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr,
|
|
|
|
u32 size) = 0;
|
|
|
|
|
2021-06-01 12:26:43 -05:00
|
|
|
/// Signal disabling of a uniform buffer
|
|
|
|
virtual void DisableGraphicsUniformBuffer(size_t stage, u32 index) = 0;
|
|
|
|
|
2020-02-19 11:40:37 -06:00
|
|
|
/// Signal a GPU based semaphore as a fence
|
2022-02-05 18:16:11 -06:00
|
|
|
virtual void SignalFence(std::function<void()>&& func) = 0;
|
|
|
|
|
|
|
|
/// Send an operation to be done after a certain amount of flushes.
|
|
|
|
virtual void SyncOperation(std::function<void()>&& func) = 0;
|
2020-02-19 11:40:37 -06:00
|
|
|
|
|
|
|
/// Signal a GPU based syncpoint as a fence
|
|
|
|
virtual void SignalSyncPoint(u32 value) = 0;
|
2020-02-17 16:10:23 -06:00
|
|
|
|
2021-07-06 15:23:10 -05:00
|
|
|
/// Signal a GPU based reference as point
|
|
|
|
virtual void SignalReference() = 0;
|
|
|
|
|
2020-02-18 11:24:38 -06:00
|
|
|
/// Release all pending fences.
|
2023-08-03 20:32:30 -05:00
|
|
|
virtual void ReleaseFences(bool force = true) = 0;
|
2020-02-17 16:10:23 -06:00
|
|
|
|
2018-04-04 16:07:58 -05:00
|
|
|
/// Notify rasterizer that all caches should be flushed to Switch memory
|
2018-03-19 22:00:59 -05:00
|
|
|
virtual void FlushAll() = 0;
|
|
|
|
|
2018-04-04 16:07:58 -05:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual void FlushRegion(DAddr addr, u64 size,
|
2022-11-19 20:07:14 -06:00
|
|
|
VideoCommon::CacheType which = VideoCommon::CacheType::All) = 0;
|
2018-03-19 22:00:59 -05:00
|
|
|
|
2020-04-16 11:29:53 -05:00
|
|
|
/// Check if the the specified memory area requires flushing to CPU Memory.
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual bool MustFlushRegion(DAddr addr, u64 size,
|
2022-11-19 20:07:14 -06:00
|
|
|
VideoCommon::CacheType which = VideoCommon::CacheType::All) = 0;
|
2020-02-17 20:29:04 -06:00
|
|
|
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual RasterizerDownloadArea GetFlushArea(DAddr addr, u64 size) = 0;
|
2023-04-30 10:14:06 -05:00
|
|
|
|
2018-03-19 22:00:59 -05:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be invalidated
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual void InvalidateRegion(DAddr addr, u64 size,
|
2022-11-19 20:07:14 -06:00
|
|
|
VideoCommon::CacheType which = VideoCommon::CacheType::All) = 0;
|
2018-03-19 22:00:59 -05:00
|
|
|
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual void InnerInvalidation(std::span<const std::pair<DAddr, std::size_t>> sequences) {
|
2023-01-05 05:43:54 -06:00
|
|
|
for (const auto& [cpu_addr, size] : sequences) {
|
2023-01-04 21:05:20 -06:00
|
|
|
InvalidateRegion(cpu_addr, size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-16 07:51:37 -06:00
|
|
|
/// Notify rasterizer that any caches of the specified region are desync with guest
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual void OnCacheInvalidation(PAddr addr, u64 size) = 0;
|
2023-06-28 12:32:50 -05:00
|
|
|
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual bool OnCPUWrite(PAddr addr, u64 size) = 0;
|
2020-02-16 07:51:37 -06:00
|
|
|
|
|
|
|
/// Sync memory between guest and host.
|
2022-02-05 18:16:11 -06:00
|
|
|
virtual void InvalidateGPUCache() = 0;
|
2020-02-16 07:51:37 -06:00
|
|
|
|
2020-12-29 23:25:23 -06:00
|
|
|
/// Unmap memory range
|
2023-12-25 00:32:16 -06:00
|
|
|
virtual void UnmapMemory(DAddr addr, u64 size) = 0;
|
2020-12-29 23:25:23 -06:00
|
|
|
|
2021-06-20 05:25:59 -05:00
|
|
|
/// Remap GPU memory range. This means underneath backing memory changed
|
2022-01-01 15:03:37 -06:00
|
|
|
virtual void ModifyGPUMemory(size_t as_id, GPUVAddr addr, u64 size) = 0;
|
2021-06-12 08:52:27 -05:00
|
|
|
|
2018-04-04 16:07:58 -05:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2018-03-19 22:00:59 -05:00
|
|
|
/// and invalidated
|
2022-11-19 20:07:14 -06:00
|
|
|
virtual void FlushAndInvalidateRegion(
|
2023-12-25 00:32:16 -06:00
|
|
|
DAddr addr, u64 size, VideoCommon::CacheType which = VideoCommon::CacheType::All) = 0;
|
2018-03-19 22:00:59 -05:00
|
|
|
|
2020-04-28 00:14:11 -05:00
|
|
|
/// Notify the host renderer to wait for previous primitive and compute operations.
|
|
|
|
virtual void WaitForIdle() = 0;
|
|
|
|
|
2020-12-29 23:25:23 -06: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 13:08:00 -05:00
|
|
|
/// Notify the rasterizer to send all written commands to the host GPU.
|
2019-07-26 13:20:43 -05:00
|
|
|
virtual void FlushCommands() = 0;
|
|
|
|
|
2019-06-20 01:22:25 -05:00
|
|
|
/// Notify rasterizer that a frame is about to finish
|
|
|
|
virtual void TickFrame() = 0;
|
|
|
|
|
2022-12-06 17:28:35 -06:00
|
|
|
virtual bool AccelerateConditionalRendering() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-10-05 22:39:03 -05:00
|
|
|
/// Attempt to use a faster method to perform a surface copy
|
2020-11-17 06:17:43 -06:00
|
|
|
[[nodiscard]] virtual bool AccelerateSurfaceCopy(
|
2020-12-29 23:25:23 -06:00
|
|
|
const Tegra::Engines::Fermi2D::Surface& src, const Tegra::Engines::Fermi2D::Surface& dst,
|
2020-11-17 06:17:43 -06:00
|
|
|
const Tegra::Engines::Fermi2D::Config& copy_config) {
|
2018-03-19 22:00:59 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-07-10 11:19:10 -05:00
|
|
|
[[nodiscard]] virtual Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() = 0;
|
|
|
|
|
2022-01-31 16:41:29 -06:00
|
|
|
virtual void AccelerateInlineToMemory(GPUVAddr address, size_t copy_size,
|
2022-08-14 04:36:36 -05:00
|
|
|
std::span<const u8> memory) = 0;
|
2022-01-29 15:00:49 -06:00
|
|
|
|
2019-01-13 19:05:53 -06:00
|
|
|
/// Initialize disk cached resources for the game being emulated
|
2021-06-21 22:04:55 -05:00
|
|
|
virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
|
2020-06-11 19:24:45 -05:00
|
|
|
const DiskResourceLoadCallback& callback) {}
|
2021-11-05 09:52:31 -05:00
|
|
|
|
|
|
|
virtual void InitializeChannel(Tegra::Control::ChannelState& channel) {}
|
|
|
|
|
|
|
|
virtual void BindChannel(Tegra::Control::ChannelState& channel) {}
|
|
|
|
|
|
|
|
virtual void ReleaseChannel(s32 channel_id) {}
|
2023-12-19 15:25:08 -06:00
|
|
|
|
|
|
|
/// Register the address as a Transform Feedback Object
|
|
|
|
virtual void RegisterTransformFeedback(GPUVAddr tfb_object_addr) {}
|
|
|
|
|
|
|
|
/// Returns true when the rasterizer has Draw Transform Feedback capabilities
|
|
|
|
virtual bool HasDrawTransformFeedback() {
|
|
|
|
return false;
|
|
|
|
}
|
2018-03-19 22:00:59 -05:00
|
|
|
};
|
|
|
|
} // namespace VideoCore
|