suyu/src/video_core/rasterizer_interface.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

177 lines
6.3 KiB
C++
Raw Normal View History

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