Merge pull request #2675 from ReinUsesLisp/opengl-buffer-cache
buffer_cache: Implement a generic buffer cache and its OpenGL backend
This commit is contained in:
commit
3477b92289
|
@ -1,4 +1,5 @@
|
||||||
add_library(video_core STATIC
|
add_library(video_core STATIC
|
||||||
|
buffer_cache.h
|
||||||
dma_pusher.cpp
|
dma_pusher.cpp
|
||||||
dma_pusher.h
|
dma_pusher.h
|
||||||
debug_utils/debug_utils.cpp
|
debug_utils/debug_utils.cpp
|
||||||
|
@ -43,8 +44,6 @@ add_library(video_core STATIC
|
||||||
renderer_opengl/gl_device.h
|
renderer_opengl/gl_device.h
|
||||||
renderer_opengl/gl_framebuffer_cache.cpp
|
renderer_opengl/gl_framebuffer_cache.cpp
|
||||||
renderer_opengl/gl_framebuffer_cache.h
|
renderer_opengl/gl_framebuffer_cache.h
|
||||||
renderer_opengl/gl_global_cache.cpp
|
|
||||||
renderer_opengl/gl_global_cache.h
|
|
||||||
renderer_opengl/gl_rasterizer.cpp
|
renderer_opengl/gl_rasterizer.cpp
|
||||||
renderer_opengl/gl_rasterizer.h
|
renderer_opengl/gl_rasterizer.h
|
||||||
renderer_opengl/gl_resource_manager.cpp
|
renderer_opengl/gl_resource_manager.cpp
|
||||||
|
|
|
@ -0,0 +1,299 @@
|
||||||
|
// Copyright 2019 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
#include <memory>
|
||||||
|
#include <mutex>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <unordered_set>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "common/alignment.h"
|
||||||
|
#include "common/common_types.h"
|
||||||
|
#include "core/core.h"
|
||||||
|
#include "video_core/memory_manager.h"
|
||||||
|
#include "video_core/rasterizer_cache.h"
|
||||||
|
|
||||||
|
namespace VideoCore {
|
||||||
|
class RasterizerInterface;
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace VideoCommon {
|
||||||
|
|
||||||
|
template <typename BufferStorageType>
|
||||||
|
class CachedBuffer final : public RasterizerCacheObject {
|
||||||
|
public:
|
||||||
|
explicit CachedBuffer(VAddr cpu_addr, u8* host_ptr)
|
||||||
|
: RasterizerCacheObject{host_ptr}, host_ptr{host_ptr}, cpu_addr{cpu_addr} {}
|
||||||
|
~CachedBuffer() override = default;
|
||||||
|
|
||||||
|
VAddr GetCpuAddr() const override {
|
||||||
|
return cpu_addr;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t GetSizeInBytes() const override {
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
u8* GetWritableHostPtr() const {
|
||||||
|
return host_ptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t GetSize() const {
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t GetCapacity() const {
|
||||||
|
return capacity;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsInternalized() const {
|
||||||
|
return is_internal;
|
||||||
|
}
|
||||||
|
|
||||||
|
const BufferStorageType& GetBuffer() const {
|
||||||
|
return buffer;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetSize(std::size_t new_size) {
|
||||||
|
size = new_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetInternalState(bool is_internal_) {
|
||||||
|
is_internal = is_internal_;
|
||||||
|
}
|
||||||
|
|
||||||
|
BufferStorageType ExchangeBuffer(BufferStorageType buffer_, std::size_t new_capacity) {
|
||||||
|
capacity = new_capacity;
|
||||||
|
std::swap(buffer, buffer_);
|
||||||
|
return buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
u8* host_ptr{};
|
||||||
|
VAddr cpu_addr{};
|
||||||
|
std::size_t size{};
|
||||||
|
std::size_t capacity{};
|
||||||
|
bool is_internal{};
|
||||||
|
BufferStorageType buffer;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename BufferStorageType, typename BufferType, typename StreamBuffer>
|
||||||
|
class BufferCache : public RasterizerCache<std::shared_ptr<CachedBuffer<BufferStorageType>>> {
|
||||||
|
public:
|
||||||
|
using Buffer = std::shared_ptr<CachedBuffer<BufferStorageType>>;
|
||||||
|
using BufferInfo = std::pair<const BufferType*, u64>;
|
||||||
|
|
||||||
|
explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,
|
||||||
|
std::unique_ptr<StreamBuffer> stream_buffer)
|
||||||
|
: RasterizerCache<Buffer>{rasterizer}, system{system},
|
||||||
|
stream_buffer{std::move(stream_buffer)}, stream_buffer_handle{
|
||||||
|
this->stream_buffer->GetHandle()} {}
|
||||||
|
~BufferCache() = default;
|
||||||
|
|
||||||
|
void Unregister(const Buffer& entry) override {
|
||||||
|
std::lock_guard lock{RasterizerCache<Buffer>::mutex};
|
||||||
|
if (entry->IsInternalized()) {
|
||||||
|
internalized_entries.erase(entry->GetCacheAddr());
|
||||||
|
}
|
||||||
|
ReserveBuffer(entry);
|
||||||
|
RasterizerCache<Buffer>::Unregister(entry);
|
||||||
|
}
|
||||||
|
|
||||||
|
void TickFrame() {
|
||||||
|
marked_for_destruction_index =
|
||||||
|
(marked_for_destruction_index + 1) % marked_for_destruction_ring_buffer.size();
|
||||||
|
MarkedForDestruction().clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
|
||||||
|
bool internalize = false, bool is_written = false) {
|
||||||
|
std::lock_guard lock{RasterizerCache<Buffer>::mutex};
|
||||||
|
|
||||||
|
auto& memory_manager = system.GPU().MemoryManager();
|
||||||
|
const auto host_ptr = memory_manager.GetPointer(gpu_addr);
|
||||||
|
if (!host_ptr) {
|
||||||
|
return {GetEmptyBuffer(size), 0};
|
||||||
|
}
|
||||||
|
const auto cache_addr = ToCacheAddr(host_ptr);
|
||||||
|
|
||||||
|
// Cache management is a big overhead, so only cache entries with a given size.
|
||||||
|
// TODO: Figure out which size is the best for given games.
|
||||||
|
constexpr std::size_t max_stream_size = 0x800;
|
||||||
|
if (!internalize && size < max_stream_size &&
|
||||||
|
internalized_entries.find(cache_addr) == internalized_entries.end()) {
|
||||||
|
return StreamBufferUpload(host_ptr, size, alignment);
|
||||||
|
}
|
||||||
|
|
||||||
|
auto entry = RasterizerCache<Buffer>::TryGet(cache_addr);
|
||||||
|
if (!entry) {
|
||||||
|
return FixedBufferUpload(gpu_addr, host_ptr, size, internalize, is_written);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (entry->GetSize() < size) {
|
||||||
|
IncreaseBufferSize(entry, size);
|
||||||
|
}
|
||||||
|
if (is_written) {
|
||||||
|
entry->MarkAsModified(true, *this);
|
||||||
|
}
|
||||||
|
return {ToHandle(entry->GetBuffer()), 0};
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.
|
||||||
|
BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
|
||||||
|
std::size_t alignment = 4) {
|
||||||
|
std::lock_guard lock{RasterizerCache<Buffer>::mutex};
|
||||||
|
return StreamBufferUpload(raw_pointer, size, alignment);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Map(std::size_t max_size) {
|
||||||
|
std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);
|
||||||
|
buffer_offset = buffer_offset_base;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Finishes the upload stream, returns true on bindings invalidation.
|
||||||
|
bool Unmap() {
|
||||||
|
stream_buffer->Unmap(buffer_offset - buffer_offset_base);
|
||||||
|
return std::exchange(invalidated, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual const BufferType* GetEmptyBuffer(std::size_t size) = 0;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
void FlushObjectInner(const Buffer& entry) override {
|
||||||
|
DownloadBufferData(entry->GetBuffer(), 0, entry->GetSize(), entry->GetWritableHostPtr());
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual BufferStorageType CreateBuffer(std::size_t size) = 0;
|
||||||
|
|
||||||
|
virtual const BufferType* ToHandle(const BufferStorageType& storage) = 0;
|
||||||
|
|
||||||
|
virtual void UploadBufferData(const BufferStorageType& buffer, std::size_t offset,
|
||||||
|
std::size_t size, const u8* data) = 0;
|
||||||
|
|
||||||
|
virtual void DownloadBufferData(const BufferStorageType& buffer, std::size_t offset,
|
||||||
|
std::size_t size, u8* data) = 0;
|
||||||
|
|
||||||
|
virtual void CopyBufferData(const BufferStorageType& src, const BufferStorageType& dst,
|
||||||
|
std::size_t src_offset, std::size_t dst_offset,
|
||||||
|
std::size_t size) = 0;
|
||||||
|
|
||||||
|
private:
|
||||||
|
BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,
|
||||||
|
std::size_t alignment) {
|
||||||
|
AlignBuffer(alignment);
|
||||||
|
const std::size_t uploaded_offset = buffer_offset;
|
||||||
|
std::memcpy(buffer_ptr, raw_pointer, size);
|
||||||
|
|
||||||
|
buffer_ptr += size;
|
||||||
|
buffer_offset += size;
|
||||||
|
return {&stream_buffer_handle, uploaded_offset};
|
||||||
|
}
|
||||||
|
|
||||||
|
BufferInfo FixedBufferUpload(GPUVAddr gpu_addr, u8* host_ptr, std::size_t size,
|
||||||
|
bool internalize, bool is_written) {
|
||||||
|
auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
|
||||||
|
const auto cpu_addr = memory_manager.GpuToCpuAddress(gpu_addr);
|
||||||
|
ASSERT(cpu_addr);
|
||||||
|
|
||||||
|
auto entry = GetUncachedBuffer(*cpu_addr, host_ptr);
|
||||||
|
entry->SetSize(size);
|
||||||
|
entry->SetInternalState(internalize);
|
||||||
|
RasterizerCache<Buffer>::Register(entry);
|
||||||
|
|
||||||
|
if (internalize) {
|
||||||
|
internalized_entries.emplace(ToCacheAddr(host_ptr));
|
||||||
|
}
|
||||||
|
if (is_written) {
|
||||||
|
entry->MarkAsModified(true, *this);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (entry->GetCapacity() < size) {
|
||||||
|
MarkedForDestruction().push_back(entry->ExchangeBuffer(CreateBuffer(size), size));
|
||||||
|
}
|
||||||
|
|
||||||
|
UploadBufferData(entry->GetBuffer(), 0, size, host_ptr);
|
||||||
|
return {ToHandle(entry->GetBuffer()), 0};
|
||||||
|
}
|
||||||
|
|
||||||
|
void IncreaseBufferSize(Buffer& entry, std::size_t new_size) {
|
||||||
|
const std::size_t old_size = entry->GetSize();
|
||||||
|
if (entry->GetCapacity() < new_size) {
|
||||||
|
const auto& old_buffer = entry->GetBuffer();
|
||||||
|
auto new_buffer = CreateBuffer(new_size);
|
||||||
|
|
||||||
|
// Copy bits from the old buffer to the new buffer.
|
||||||
|
CopyBufferData(old_buffer, new_buffer, 0, 0, old_size);
|
||||||
|
MarkedForDestruction().push_back(
|
||||||
|
entry->ExchangeBuffer(std::move(new_buffer), new_size));
|
||||||
|
|
||||||
|
// This buffer could have been used
|
||||||
|
invalidated = true;
|
||||||
|
}
|
||||||
|
// Upload the new bits.
|
||||||
|
const std::size_t size_diff = new_size - old_size;
|
||||||
|
UploadBufferData(entry->GetBuffer(), old_size, size_diff, entry->GetHostPtr() + old_size);
|
||||||
|
|
||||||
|
// Update entry's size in the object and in the cache.
|
||||||
|
Unregister(entry);
|
||||||
|
|
||||||
|
entry->SetSize(new_size);
|
||||||
|
RasterizerCache<Buffer>::Register(entry);
|
||||||
|
}
|
||||||
|
|
||||||
|
Buffer GetUncachedBuffer(VAddr cpu_addr, u8* host_ptr) {
|
||||||
|
if (auto entry = TryGetReservedBuffer(host_ptr)) {
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
return std::make_shared<CachedBuffer<BufferStorageType>>(cpu_addr, host_ptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
Buffer TryGetReservedBuffer(u8* host_ptr) {
|
||||||
|
const auto it = buffer_reserve.find(ToCacheAddr(host_ptr));
|
||||||
|
if (it == buffer_reserve.end()) {
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
auto& reserve = it->second;
|
||||||
|
auto entry = reserve.back();
|
||||||
|
reserve.pop_back();
|
||||||
|
return entry;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ReserveBuffer(Buffer entry) {
|
||||||
|
buffer_reserve[entry->GetCacheAddr()].push_back(std::move(entry));
|
||||||
|
}
|
||||||
|
|
||||||
|
void AlignBuffer(std::size_t alignment) {
|
||||||
|
// Align the offset, not the mapped pointer
|
||||||
|
const std::size_t offset_aligned = Common::AlignUp(buffer_offset, alignment);
|
||||||
|
buffer_ptr += offset_aligned - buffer_offset;
|
||||||
|
buffer_offset = offset_aligned;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<BufferStorageType>& MarkedForDestruction() {
|
||||||
|
return marked_for_destruction_ring_buffer[marked_for_destruction_index];
|
||||||
|
}
|
||||||
|
|
||||||
|
Core::System& system;
|
||||||
|
|
||||||
|
std::unique_ptr<StreamBuffer> stream_buffer;
|
||||||
|
BufferType stream_buffer_handle{};
|
||||||
|
|
||||||
|
bool invalidated = false;
|
||||||
|
|
||||||
|
u8* buffer_ptr = nullptr;
|
||||||
|
u64 buffer_offset = 0;
|
||||||
|
u64 buffer_offset_base = 0;
|
||||||
|
|
||||||
|
std::size_t marked_for_destruction_index = 0;
|
||||||
|
std::array<std::vector<BufferStorageType>, 4> marked_for_destruction_ring_buffer;
|
||||||
|
|
||||||
|
std::unordered_set<CacheAddr> internalized_entries;
|
||||||
|
std::unordered_map<CacheAddr, std::vector<Buffer>> buffer_reserve;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace VideoCommon
|
|
@ -67,6 +67,7 @@ public:
|
||||||
static constexpr std::size_t MaxShaderStage = 5;
|
static constexpr std::size_t MaxShaderStage = 5;
|
||||||
// Maximum number of const buffers per shader stage.
|
// Maximum number of const buffers per shader stage.
|
||||||
static constexpr std::size_t MaxConstBuffers = 18;
|
static constexpr std::size_t MaxConstBuffers = 18;
|
||||||
|
static constexpr std::size_t MaxConstBufferSize = 0x10000;
|
||||||
|
|
||||||
enum class QueryMode : u32 {
|
enum class QueryMode : u32 {
|
||||||
Write = 0,
|
Write = 0,
|
||||||
|
|
|
@ -47,6 +47,9 @@ public:
|
||||||
/// and invalidated
|
/// and invalidated
|
||||||
virtual void FlushAndInvalidateRegion(CacheAddr addr, u64 size) = 0;
|
virtual void FlushAndInvalidateRegion(CacheAddr addr, u64 size) = 0;
|
||||||
|
|
||||||
|
/// Notify rasterizer that a frame is about to finish
|
||||||
|
virtual void TickFrame() = 0;
|
||||||
|
|
||||||
/// Attempt to use a faster method to perform a surface copy
|
/// Attempt to use a faster method to perform a surface copy
|
||||||
virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
|
|
|
@ -2,103 +2,57 @@
|
||||||
// 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 <cstring>
|
|
||||||
#include <memory>
|
#include <memory>
|
||||||
|
|
||||||
#include "common/alignment.h"
|
#include <glad/glad.h>
|
||||||
#include "core/core.h"
|
|
||||||
#include "video_core/memory_manager.h"
|
#include "common/assert.h"
|
||||||
#include "video_core/renderer_opengl/gl_buffer_cache.h"
|
#include "video_core/renderer_opengl/gl_buffer_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
||||||
|
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
||||||
|
|
||||||
namespace OpenGL {
|
namespace OpenGL {
|
||||||
|
|
||||||
CachedBufferEntry::CachedBufferEntry(VAddr cpu_addr, std::size_t size, GLintptr offset,
|
OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, Core::System& system,
|
||||||
std::size_t alignment, u8* host_ptr)
|
std::size_t stream_size)
|
||||||
: RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr}, size{size}, offset{offset},
|
: VideoCommon::BufferCache<OGLBuffer, GLuint, OGLStreamBuffer>{
|
||||||
alignment{alignment} {}
|
rasterizer, system, std::make_unique<OGLStreamBuffer>(stream_size, true)} {}
|
||||||
|
|
||||||
OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, std::size_t size)
|
OGLBufferCache::~OGLBufferCache() = default;
|
||||||
: RasterizerCache{rasterizer}, stream_buffer(size, true) {}
|
|
||||||
|
|
||||||
GLintptr OGLBufferCache::UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment,
|
OGLBuffer OGLBufferCache::CreateBuffer(std::size_t size) {
|
||||||
bool cache) {
|
OGLBuffer buffer;
|
||||||
std::lock_guard lock{mutex};
|
buffer.Create();
|
||||||
auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
|
glNamedBufferData(buffer.handle, static_cast<GLsizeiptr>(size), nullptr, GL_DYNAMIC_DRAW);
|
||||||
|
return buffer;
|
||||||
// Cache management is a big overhead, so only cache entries with a given size.
|
|
||||||
// TODO: Figure out which size is the best for given games.
|
|
||||||
cache &= size >= 2048;
|
|
||||||
|
|
||||||
const auto& host_ptr{memory_manager.GetPointer(gpu_addr)};
|
|
||||||
if (cache) {
|
|
||||||
auto entry = TryGet(host_ptr);
|
|
||||||
if (entry) {
|
|
||||||
if (entry->GetSize() >= size && entry->GetAlignment() == alignment) {
|
|
||||||
return entry->GetOffset();
|
|
||||||
}
|
|
||||||
Unregister(entry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
AlignBuffer(alignment);
|
|
||||||
const GLintptr uploaded_offset = buffer_offset;
|
|
||||||
|
|
||||||
if (!host_ptr) {
|
|
||||||
return uploaded_offset;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::memcpy(buffer_ptr, host_ptr, size);
|
|
||||||
buffer_ptr += size;
|
|
||||||
buffer_offset += size;
|
|
||||||
|
|
||||||
if (cache) {
|
|
||||||
auto entry = std::make_shared<CachedBufferEntry>(
|
|
||||||
*memory_manager.GpuToCpuAddress(gpu_addr), size, uploaded_offset, alignment, host_ptr);
|
|
||||||
Register(entry);
|
|
||||||
}
|
|
||||||
|
|
||||||
return uploaded_offset;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
GLintptr OGLBufferCache::UploadHostMemory(const void* raw_pointer, std::size_t size,
|
const GLuint* OGLBufferCache::ToHandle(const OGLBuffer& buffer) {
|
||||||
std::size_t alignment) {
|
return &buffer.handle;
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
AlignBuffer(alignment);
|
|
||||||
std::memcpy(buffer_ptr, raw_pointer, size);
|
|
||||||
const GLintptr uploaded_offset = buffer_offset;
|
|
||||||
|
|
||||||
buffer_ptr += size;
|
|
||||||
buffer_offset += size;
|
|
||||||
return uploaded_offset;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool OGLBufferCache::Map(std::size_t max_size) {
|
const GLuint* OGLBufferCache::GetEmptyBuffer(std::size_t) {
|
||||||
bool invalidate;
|
static const GLuint null_buffer = 0;
|
||||||
std::tie(buffer_ptr, buffer_offset_base, invalidate) =
|
return &null_buffer;
|
||||||
stream_buffer.Map(static_cast<GLsizeiptr>(max_size), 4);
|
|
||||||
buffer_offset = buffer_offset_base;
|
|
||||||
|
|
||||||
if (invalidate) {
|
|
||||||
InvalidateAll();
|
|
||||||
}
|
|
||||||
return invalidate;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void OGLBufferCache::Unmap() {
|
void OGLBufferCache::UploadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,
|
||||||
stream_buffer.Unmap(buffer_offset - buffer_offset_base);
|
const u8* data) {
|
||||||
|
glNamedBufferSubData(buffer.handle, static_cast<GLintptr>(offset),
|
||||||
|
static_cast<GLsizeiptr>(size), data);
|
||||||
}
|
}
|
||||||
|
|
||||||
GLuint OGLBufferCache::GetHandle() const {
|
void OGLBufferCache::DownloadBufferData(const OGLBuffer& buffer, std::size_t offset,
|
||||||
return stream_buffer.GetHandle();
|
std::size_t size, u8* data) {
|
||||||
|
glGetNamedBufferSubData(buffer.handle, static_cast<GLintptr>(offset),
|
||||||
|
static_cast<GLsizeiptr>(size), data);
|
||||||
}
|
}
|
||||||
|
|
||||||
void OGLBufferCache::AlignBuffer(std::size_t alignment) {
|
void OGLBufferCache::CopyBufferData(const OGLBuffer& src, const OGLBuffer& dst,
|
||||||
// Align the offset, not the mapped pointer
|
std::size_t src_offset, std::size_t dst_offset,
|
||||||
const GLintptr offset_aligned =
|
std::size_t size) {
|
||||||
static_cast<GLintptr>(Common::AlignUp(static_cast<std::size_t>(buffer_offset), alignment));
|
glCopyNamedBufferSubData(src.handle, dst.handle, static_cast<GLintptr>(src_offset),
|
||||||
buffer_ptr += offset_aligned - buffer_offset;
|
static_cast<GLintptr>(dst_offset), static_cast<GLsizeiptr>(size));
|
||||||
buffer_offset = offset_aligned;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace OpenGL
|
} // namespace OpenGL
|
||||||
|
|
|
@ -4,80 +4,44 @@
|
||||||
|
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <cstddef>
|
|
||||||
#include <memory>
|
#include <memory>
|
||||||
#include <tuple>
|
|
||||||
|
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
|
#include "video_core/buffer_cache.h"
|
||||||
#include "video_core/rasterizer_cache.h"
|
#include "video_core/rasterizer_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
||||||
#include "video_core/renderer_opengl/gl_stream_buffer.h"
|
#include "video_core/renderer_opengl/gl_stream_buffer.h"
|
||||||
|
|
||||||
|
namespace Core {
|
||||||
|
class System;
|
||||||
|
}
|
||||||
|
|
||||||
namespace OpenGL {
|
namespace OpenGL {
|
||||||
|
|
||||||
|
class OGLStreamBuffer;
|
||||||
class RasterizerOpenGL;
|
class RasterizerOpenGL;
|
||||||
|
|
||||||
class CachedBufferEntry final : public RasterizerCacheObject {
|
class OGLBufferCache final : public VideoCommon::BufferCache<OGLBuffer, GLuint, OGLStreamBuffer> {
|
||||||
public:
|
public:
|
||||||
explicit CachedBufferEntry(VAddr cpu_addr, std::size_t size, GLintptr offset,
|
explicit OGLBufferCache(RasterizerOpenGL& rasterizer, Core::System& system,
|
||||||
std::size_t alignment, u8* host_ptr);
|
std::size_t stream_size);
|
||||||
|
~OGLBufferCache();
|
||||||
|
|
||||||
VAddr GetCpuAddr() const override {
|
const GLuint* GetEmptyBuffer(std::size_t) override;
|
||||||
return cpu_addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t GetSizeInBytes() const override {
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t GetSize() const {
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
GLintptr GetOffset() const {
|
|
||||||
return offset;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t GetAlignment() const {
|
|
||||||
return alignment;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
VAddr cpu_addr{};
|
|
||||||
std::size_t size{};
|
|
||||||
GLintptr offset{};
|
|
||||||
std::size_t alignment{};
|
|
||||||
};
|
|
||||||
|
|
||||||
class OGLBufferCache final : public RasterizerCache<std::shared_ptr<CachedBufferEntry>> {
|
|
||||||
public:
|
|
||||||
explicit OGLBufferCache(RasterizerOpenGL& rasterizer, std::size_t size);
|
|
||||||
|
|
||||||
/// Uploads data from a guest GPU address. Returns host's buffer offset where it's been
|
|
||||||
/// allocated.
|
|
||||||
GLintptr UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
|
|
||||||
bool cache = true);
|
|
||||||
|
|
||||||
/// Uploads from a host memory. Returns host's buffer offset where it's been allocated.
|
|
||||||
GLintptr UploadHostMemory(const void* raw_pointer, std::size_t size, std::size_t alignment = 4);
|
|
||||||
|
|
||||||
bool Map(std::size_t max_size);
|
|
||||||
void Unmap();
|
|
||||||
|
|
||||||
GLuint GetHandle() const;
|
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
void AlignBuffer(std::size_t alignment);
|
OGLBuffer CreateBuffer(std::size_t size) override;
|
||||||
|
|
||||||
// We do not have to flush this cache as things in it are never modified by us.
|
const GLuint* ToHandle(const OGLBuffer& buffer) override;
|
||||||
void FlushObjectInner(const std::shared_ptr<CachedBufferEntry>& object) override {}
|
|
||||||
|
|
||||||
private:
|
void UploadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,
|
||||||
OGLStreamBuffer stream_buffer;
|
const u8* data) override;
|
||||||
|
|
||||||
u8* buffer_ptr = nullptr;
|
void DownloadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,
|
||||||
GLintptr buffer_offset = 0;
|
u8* data) override;
|
||||||
GLintptr buffer_offset_base = 0;
|
|
||||||
|
void CopyBufferData(const OGLBuffer& src, const OGLBuffer& dst, std::size_t src_offset,
|
||||||
|
std::size_t dst_offset, std::size_t size) override;
|
||||||
};
|
};
|
||||||
|
|
||||||
} // namespace OpenGL
|
} // namespace OpenGL
|
||||||
|
|
|
@ -24,6 +24,7 @@ T GetInteger(GLenum pname) {
|
||||||
|
|
||||||
Device::Device() {
|
Device::Device() {
|
||||||
uniform_buffer_alignment = GetInteger<std::size_t>(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
|
uniform_buffer_alignment = GetInteger<std::size_t>(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
|
||||||
|
shader_storage_alignment = GetInteger<std::size_t>(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT);
|
||||||
max_vertex_attributes = GetInteger<u32>(GL_MAX_VERTEX_ATTRIBS);
|
max_vertex_attributes = GetInteger<u32>(GL_MAX_VERTEX_ATTRIBS);
|
||||||
max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
|
max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
|
||||||
has_variable_aoffi = TestVariableAoffi();
|
has_variable_aoffi = TestVariableAoffi();
|
||||||
|
|
|
@ -18,6 +18,10 @@ public:
|
||||||
return uniform_buffer_alignment;
|
return uniform_buffer_alignment;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
std::size_t GetShaderStorageBufferAlignment() const {
|
||||||
|
return shader_storage_alignment;
|
||||||
|
}
|
||||||
|
|
||||||
u32 GetMaxVertexAttributes() const {
|
u32 GetMaxVertexAttributes() const {
|
||||||
return max_vertex_attributes;
|
return max_vertex_attributes;
|
||||||
}
|
}
|
||||||
|
@ -39,6 +43,7 @@ private:
|
||||||
static bool TestComponentIndexingBug();
|
static bool TestComponentIndexingBug();
|
||||||
|
|
||||||
std::size_t uniform_buffer_alignment{};
|
std::size_t uniform_buffer_alignment{};
|
||||||
|
std::size_t shader_storage_alignment{};
|
||||||
u32 max_vertex_attributes{};
|
u32 max_vertex_attributes{};
|
||||||
u32 max_varyings{};
|
u32 max_varyings{};
|
||||||
bool has_variable_aoffi{};
|
bool has_variable_aoffi{};
|
||||||
|
|
|
@ -1,102 +0,0 @@
|
||||||
// Copyright 2018 yuzu Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#include <glad/glad.h>
|
|
||||||
|
|
||||||
#include "common/logging/log.h"
|
|
||||||
#include "core/core.h"
|
|
||||||
#include "video_core/memory_manager.h"
|
|
||||||
#include "video_core/renderer_opengl/gl_global_cache.h"
|
|
||||||
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
|
||||||
#include "video_core/renderer_opengl/gl_shader_decompiler.h"
|
|
||||||
#include "video_core/renderer_opengl/utils.h"
|
|
||||||
|
|
||||||
namespace OpenGL {
|
|
||||||
|
|
||||||
CachedGlobalRegion::CachedGlobalRegion(VAddr cpu_addr, u8* host_ptr, u32 size, u32 max_size)
|
|
||||||
: RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr}, host_ptr{host_ptr}, size{size},
|
|
||||||
max_size{max_size} {
|
|
||||||
buffer.Create();
|
|
||||||
LabelGLObject(GL_BUFFER, buffer.handle, cpu_addr, "GlobalMemory");
|
|
||||||
}
|
|
||||||
|
|
||||||
CachedGlobalRegion::~CachedGlobalRegion() = default;
|
|
||||||
|
|
||||||
void CachedGlobalRegion::Reload(u32 size_) {
|
|
||||||
size = size_;
|
|
||||||
if (size > max_size) {
|
|
||||||
size = max_size;
|
|
||||||
LOG_CRITICAL(HW_GPU, "Global region size {} exceeded the supported size {}!", size_,
|
|
||||||
max_size);
|
|
||||||
}
|
|
||||||
glNamedBufferData(buffer.handle, size, host_ptr, GL_STREAM_DRAW);
|
|
||||||
}
|
|
||||||
|
|
||||||
void CachedGlobalRegion::Flush() {
|
|
||||||
LOG_DEBUG(Render_OpenGL, "Flushing {} bytes to CPU memory address 0x{:16}", size, cpu_addr);
|
|
||||||
glGetNamedBufferSubData(buffer.handle, 0, static_cast<GLsizeiptr>(size), host_ptr);
|
|
||||||
}
|
|
||||||
|
|
||||||
GlobalRegion GlobalRegionCacheOpenGL::TryGetReservedGlobalRegion(CacheAddr addr, u32 size) const {
|
|
||||||
const auto search{reserve.find(addr)};
|
|
||||||
if (search == reserve.end()) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
return search->second;
|
|
||||||
}
|
|
||||||
|
|
||||||
GlobalRegion GlobalRegionCacheOpenGL::GetUncachedGlobalRegion(GPUVAddr addr, u8* host_ptr,
|
|
||||||
u32 size) {
|
|
||||||
GlobalRegion region{TryGetReservedGlobalRegion(ToCacheAddr(host_ptr), size)};
|
|
||||||
if (!region) {
|
|
||||||
// No reserved surface available, create a new one and reserve it
|
|
||||||
auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
|
|
||||||
const auto cpu_addr{memory_manager.GpuToCpuAddress(addr)};
|
|
||||||
ASSERT(cpu_addr);
|
|
||||||
|
|
||||||
region = std::make_shared<CachedGlobalRegion>(*cpu_addr, host_ptr, size, max_ssbo_size);
|
|
||||||
ReserveGlobalRegion(region);
|
|
||||||
}
|
|
||||||
region->Reload(size);
|
|
||||||
return region;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GlobalRegionCacheOpenGL::ReserveGlobalRegion(GlobalRegion region) {
|
|
||||||
reserve.insert_or_assign(region->GetCacheAddr(), std::move(region));
|
|
||||||
}
|
|
||||||
|
|
||||||
GlobalRegionCacheOpenGL::GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer)
|
|
||||||
: RasterizerCache{rasterizer} {
|
|
||||||
GLint max_ssbo_size_;
|
|
||||||
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_ssbo_size_);
|
|
||||||
max_ssbo_size = static_cast<u32>(max_ssbo_size_);
|
|
||||||
}
|
|
||||||
|
|
||||||
GlobalRegion GlobalRegionCacheOpenGL::GetGlobalRegion(
|
|
||||||
const GLShader::GlobalMemoryEntry& global_region,
|
|
||||||
Tegra::Engines::Maxwell3D::Regs::ShaderStage stage) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
auto& gpu{Core::System::GetInstance().GPU()};
|
|
||||||
auto& memory_manager{gpu.MemoryManager()};
|
|
||||||
const auto cbufs{gpu.Maxwell3D().state.shader_stages[static_cast<std::size_t>(stage)]};
|
|
||||||
const auto addr{cbufs.const_buffers[global_region.GetCbufIndex()].address +
|
|
||||||
global_region.GetCbufOffset()};
|
|
||||||
const auto actual_addr{memory_manager.Read<u64>(addr)};
|
|
||||||
const auto size{memory_manager.Read<u32>(addr + 8)};
|
|
||||||
|
|
||||||
// Look up global region in the cache based on address
|
|
||||||
const auto& host_ptr{memory_manager.GetPointer(actual_addr)};
|
|
||||||
GlobalRegion region{TryGet(host_ptr)};
|
|
||||||
|
|
||||||
if (!region) {
|
|
||||||
// No global region found - create a new one
|
|
||||||
region = GetUncachedGlobalRegion(actual_addr, host_ptr, size);
|
|
||||||
Register(region);
|
|
||||||
}
|
|
||||||
|
|
||||||
return region;
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace OpenGL
|
|
|
@ -1,82 +0,0 @@
|
||||||
// Copyright 2018 yuzu Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <memory>
|
|
||||||
#include <unordered_map>
|
|
||||||
|
|
||||||
#include <glad/glad.h>
|
|
||||||
|
|
||||||
#include "common/assert.h"
|
|
||||||
#include "common/common_types.h"
|
|
||||||
#include "video_core/engines/maxwell_3d.h"
|
|
||||||
#include "video_core/rasterizer_cache.h"
|
|
||||||
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
|
||||||
|
|
||||||
namespace OpenGL {
|
|
||||||
|
|
||||||
namespace GLShader {
|
|
||||||
class GlobalMemoryEntry;
|
|
||||||
}
|
|
||||||
|
|
||||||
class RasterizerOpenGL;
|
|
||||||
class CachedGlobalRegion;
|
|
||||||
using GlobalRegion = std::shared_ptr<CachedGlobalRegion>;
|
|
||||||
|
|
||||||
class CachedGlobalRegion final : public RasterizerCacheObject {
|
|
||||||
public:
|
|
||||||
explicit CachedGlobalRegion(VAddr cpu_addr, u8* host_ptr, u32 size, u32 max_size);
|
|
||||||
~CachedGlobalRegion();
|
|
||||||
|
|
||||||
VAddr GetCpuAddr() const override {
|
|
||||||
return cpu_addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t GetSizeInBytes() const override {
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets the GL program handle for the buffer
|
|
||||||
GLuint GetBufferHandle() const {
|
|
||||||
return buffer.handle;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Reloads the global region from guest memory
|
|
||||||
void Reload(u32 size_);
|
|
||||||
|
|
||||||
void Flush();
|
|
||||||
|
|
||||||
private:
|
|
||||||
VAddr cpu_addr{};
|
|
||||||
u8* host_ptr{};
|
|
||||||
u32 size{};
|
|
||||||
u32 max_size{};
|
|
||||||
|
|
||||||
OGLBuffer buffer;
|
|
||||||
};
|
|
||||||
|
|
||||||
class GlobalRegionCacheOpenGL final : public RasterizerCache<GlobalRegion> {
|
|
||||||
public:
|
|
||||||
explicit GlobalRegionCacheOpenGL(RasterizerOpenGL& rasterizer);
|
|
||||||
|
|
||||||
/// Gets the current specified shader stage program
|
|
||||||
GlobalRegion GetGlobalRegion(const GLShader::GlobalMemoryEntry& descriptor,
|
|
||||||
Tegra::Engines::Maxwell3D::Regs::ShaderStage stage);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
void FlushObjectInner(const GlobalRegion& object) override {
|
|
||||||
object->Flush();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
GlobalRegion TryGetReservedGlobalRegion(CacheAddr addr, u32 size) const;
|
|
||||||
GlobalRegion GetUncachedGlobalRegion(GPUVAddr addr, u8* host_ptr, u32 size);
|
|
||||||
void ReserveGlobalRegion(GlobalRegion region);
|
|
||||||
|
|
||||||
std::unordered_map<CacheAddr, GlobalRegion> reserve;
|
|
||||||
u32 max_ssbo_size{};
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace OpenGL
|
|
|
@ -20,6 +20,7 @@
|
||||||
#include "core/hle/kernel/process.h"
|
#include "core/hle/kernel/process.h"
|
||||||
#include "core/settings.h"
|
#include "core/settings.h"
|
||||||
#include "video_core/engines/maxwell_3d.h"
|
#include "video_core/engines/maxwell_3d.h"
|
||||||
|
#include "video_core/memory_manager.h"
|
||||||
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
||||||
#include "video_core/renderer_opengl/gl_shader_cache.h"
|
#include "video_core/renderer_opengl/gl_shader_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_shader_gen.h"
|
#include "video_core/renderer_opengl/gl_shader_gen.h"
|
||||||
|
@ -80,11 +81,25 @@ struct DrawParameters {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static std::size_t GetConstBufferSize(const Tegra::Engines::ConstBufferInfo& buffer,
|
||||||
|
const GLShader::ConstBufferEntry& entry) {
|
||||||
|
if (!entry.IsIndirect()) {
|
||||||
|
return entry.GetSize();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (buffer.size > Maxwell::MaxConstBufferSize) {
|
||||||
|
LOG_WARNING(Render_OpenGL, "Indirect constbuffer size {} exceeds maximum {}", buffer.size,
|
||||||
|
Maxwell::MaxConstBufferSize);
|
||||||
|
return Maxwell::MaxConstBufferSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
return buffer.size;
|
||||||
|
}
|
||||||
|
|
||||||
RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
|
RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
|
||||||
ScreenInfo& info)
|
ScreenInfo& info)
|
||||||
: texture_cache{system, *this, device}, shader_cache{*this, system, emu_window, device},
|
: texture_cache{system, *this, device}, shader_cache{*this, system, emu_window, device},
|
||||||
global_cache{*this}, system{system}, screen_info{info},
|
system{system}, screen_info{info}, buffer_cache{*this, system, STREAM_BUFFER_SIZE} {
|
||||||
buffer_cache(*this, STREAM_BUFFER_SIZE) {
|
|
||||||
OpenGLState::ApplyDefaultState();
|
OpenGLState::ApplyDefaultState();
|
||||||
|
|
||||||
shader_program_manager = std::make_unique<GLShader::ProgramManager>();
|
shader_program_manager = std::make_unique<GLShader::ProgramManager>();
|
||||||
|
@ -129,8 +144,6 @@ GLuint RasterizerOpenGL::SetupVertexFormat() {
|
||||||
state.draw.vertex_array = vao;
|
state.draw.vertex_array = vao;
|
||||||
state.ApplyVertexArrayState();
|
state.ApplyVertexArrayState();
|
||||||
|
|
||||||
glVertexArrayElementBuffer(vao, buffer_cache.GetHandle());
|
|
||||||
|
|
||||||
// Use the vertex array as-is, assumes that the data is formatted correctly for OpenGL.
|
// Use the vertex array as-is, assumes that the data is formatted correctly for OpenGL.
|
||||||
// Enables the first 16 vertex attributes always, as we don't know which ones are actually
|
// Enables the first 16 vertex attributes always, as we don't know which ones are actually
|
||||||
// used until shader time. Note, Tegra technically supports 32, but we're capping this to 16
|
// used until shader time. Note, Tegra technically supports 32, but we're capping this to 16
|
||||||
|
@ -197,11 +210,11 @@ void RasterizerOpenGL::SetupVertexBuffer(GLuint vao) {
|
||||||
|
|
||||||
ASSERT(end > start);
|
ASSERT(end > start);
|
||||||
const u64 size = end - start + 1;
|
const u64 size = end - start + 1;
|
||||||
const GLintptr vertex_buffer_offset = buffer_cache.UploadMemory(start, size);
|
const auto [vertex_buffer, vertex_buffer_offset] = buffer_cache.UploadMemory(start, size);
|
||||||
|
|
||||||
// Bind the vertex array to the buffer at the current offset.
|
// Bind the vertex array to the buffer at the current offset.
|
||||||
glVertexArrayVertexBuffer(vao, index, buffer_cache.GetHandle(), vertex_buffer_offset,
|
vertex_array_pushbuffer.SetVertexBuffer(index, vertex_buffer, vertex_buffer_offset,
|
||||||
vertex_array.stride);
|
vertex_array.stride);
|
||||||
|
|
||||||
if (regs.instanced_arrays.IsInstancingEnabled(index) && vertex_array.divisor != 0) {
|
if (regs.instanced_arrays.IsInstancingEnabled(index) && vertex_array.divisor != 0) {
|
||||||
// Enable vertex buffer instancing with the specified divisor.
|
// Enable vertex buffer instancing with the specified divisor.
|
||||||
|
@ -215,7 +228,19 @@ void RasterizerOpenGL::SetupVertexBuffer(GLuint vao) {
|
||||||
gpu.dirty_flags.vertex_array.reset();
|
gpu.dirty_flags.vertex_array.reset();
|
||||||
}
|
}
|
||||||
|
|
||||||
DrawParameters RasterizerOpenGL::SetupDraw() {
|
GLintptr RasterizerOpenGL::SetupIndexBuffer() {
|
||||||
|
if (accelerate_draw != AccelDraw::Indexed) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
MICROPROFILE_SCOPE(OpenGL_Index);
|
||||||
|
const auto& regs = system.GPU().Maxwell3D().regs;
|
||||||
|
const std::size_t size = CalculateIndexBufferSize();
|
||||||
|
const auto [buffer, offset] = buffer_cache.UploadMemory(regs.index_array.IndexStart(), size);
|
||||||
|
vertex_array_pushbuffer.SetIndexBuffer(buffer);
|
||||||
|
return offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
DrawParameters RasterizerOpenGL::SetupDraw(GLintptr index_buffer_offset) {
|
||||||
const auto& gpu = system.GPU().Maxwell3D();
|
const auto& gpu = system.GPU().Maxwell3D();
|
||||||
const auto& regs = gpu.regs;
|
const auto& regs = gpu.regs;
|
||||||
const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
|
const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
|
||||||
|
@ -227,11 +252,9 @@ DrawParameters RasterizerOpenGL::SetupDraw() {
|
||||||
params.primitive_mode = MaxwellToGL::PrimitiveTopology(regs.draw.topology);
|
params.primitive_mode = MaxwellToGL::PrimitiveTopology(regs.draw.topology);
|
||||||
|
|
||||||
if (is_indexed) {
|
if (is_indexed) {
|
||||||
MICROPROFILE_SCOPE(OpenGL_Index);
|
|
||||||
params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
|
params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
|
||||||
params.count = regs.index_array.count;
|
params.count = regs.index_array.count;
|
||||||
params.index_buffer_offset =
|
params.index_buffer_offset = index_buffer_offset;
|
||||||
buffer_cache.UploadMemory(regs.index_array.IndexStart(), CalculateIndexBufferSize());
|
|
||||||
params.base_vertex = static_cast<GLint>(regs.vb_element_base);
|
params.base_vertex = static_cast<GLint>(regs.vb_element_base);
|
||||||
} else {
|
} else {
|
||||||
params.count = regs.vertex_buffer.count;
|
params.count = regs.vertex_buffer.count;
|
||||||
|
@ -247,10 +270,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
|
||||||
BaseBindings base_bindings;
|
BaseBindings base_bindings;
|
||||||
std::array<bool, Maxwell::NumClipDistances> clip_distances{};
|
std::array<bool, Maxwell::NumClipDistances> clip_distances{};
|
||||||
|
|
||||||
// Prepare packed bindings
|
|
||||||
bind_ubo_pushbuffer.Setup(base_bindings.cbuf);
|
|
||||||
bind_ssbo_pushbuffer.Setup(base_bindings.gmem);
|
|
||||||
|
|
||||||
for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
||||||
const auto& shader_config = gpu.regs.shader_config[index];
|
const auto& shader_config = gpu.regs.shader_config[index];
|
||||||
const Maxwell::ShaderProgram program{static_cast<Maxwell::ShaderProgram>(index)};
|
const Maxwell::ShaderProgram program{static_cast<Maxwell::ShaderProgram>(index)};
|
||||||
|
@ -271,12 +290,11 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
|
||||||
|
|
||||||
GLShader::MaxwellUniformData ubo{};
|
GLShader::MaxwellUniformData ubo{};
|
||||||
ubo.SetFromRegs(gpu, stage);
|
ubo.SetFromRegs(gpu, stage);
|
||||||
const GLintptr offset =
|
const auto [buffer, offset] =
|
||||||
buffer_cache.UploadHostMemory(&ubo, sizeof(ubo), device.GetUniformBufferAlignment());
|
buffer_cache.UploadHostMemory(&ubo, sizeof(ubo), device.GetUniformBufferAlignment());
|
||||||
|
|
||||||
// Bind the emulation info buffer
|
// Bind the emulation info buffer
|
||||||
bind_ubo_pushbuffer.Push(buffer_cache.GetHandle(), offset,
|
bind_ubo_pushbuffer.Push(buffer, offset, static_cast<GLsizeiptr>(sizeof(ubo)));
|
||||||
static_cast<GLsizeiptr>(sizeof(ubo)));
|
|
||||||
|
|
||||||
Shader shader{shader_cache.GetStageProgram(program)};
|
Shader shader{shader_cache.GetStageProgram(program)};
|
||||||
|
|
||||||
|
@ -321,9 +339,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
|
||||||
base_bindings = next_bindings;
|
base_bindings = next_bindings;
|
||||||
}
|
}
|
||||||
|
|
||||||
bind_ubo_pushbuffer.Bind();
|
|
||||||
bind_ssbo_pushbuffer.Bind();
|
|
||||||
|
|
||||||
SyncClipEnabled(clip_distances);
|
SyncClipEnabled(clip_distances);
|
||||||
|
|
||||||
gpu.dirty_flags.shaders = false;
|
gpu.dirty_flags.shaders = false;
|
||||||
|
@ -634,26 +649,46 @@ void RasterizerOpenGL::DrawArrays() {
|
||||||
Maxwell::MaxShaderStage;
|
Maxwell::MaxShaderStage;
|
||||||
|
|
||||||
// Add space for at least 18 constant buffers
|
// Add space for at least 18 constant buffers
|
||||||
buffer_size +=
|
buffer_size += Maxwell::MaxConstBuffers *
|
||||||
Maxwell::MaxConstBuffers * (MaxConstbufferSize + device.GetUniformBufferAlignment());
|
(Maxwell::MaxConstBufferSize + device.GetUniformBufferAlignment());
|
||||||
|
|
||||||
const bool invalidate = buffer_cache.Map(buffer_size);
|
// Prepare the vertex array.
|
||||||
if (invalidate) {
|
buffer_cache.Map(buffer_size);
|
||||||
// As all cached buffers are invalidated, we need to recheck their state.
|
|
||||||
gpu.dirty_flags.vertex_array.set();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
// Prepare vertex array format.
|
||||||
const GLuint vao = SetupVertexFormat();
|
const GLuint vao = SetupVertexFormat();
|
||||||
SetupVertexBuffer(vao);
|
vertex_array_pushbuffer.Setup(vao);
|
||||||
|
|
||||||
DrawParameters params = SetupDraw();
|
// Upload vertex and index data.
|
||||||
|
SetupVertexBuffer(vao);
|
||||||
|
const GLintptr index_buffer_offset = SetupIndexBuffer();
|
||||||
|
|
||||||
|
// Setup draw parameters. It will automatically choose what glDraw* method to use.
|
||||||
|
const DrawParameters params = SetupDraw(index_buffer_offset);
|
||||||
|
|
||||||
|
// Prepare packed bindings.
|
||||||
|
bind_ubo_pushbuffer.Setup(0);
|
||||||
|
bind_ssbo_pushbuffer.Setup(0);
|
||||||
|
|
||||||
|
// Setup shaders and their used resources.
|
||||||
texture_cache.GuardSamplers(true);
|
texture_cache.GuardSamplers(true);
|
||||||
SetupShaders(params.primitive_mode);
|
SetupShaders(params.primitive_mode);
|
||||||
texture_cache.GuardSamplers(false);
|
texture_cache.GuardSamplers(false);
|
||||||
|
|
||||||
ConfigureFramebuffers(state);
|
ConfigureFramebuffers(state);
|
||||||
|
|
||||||
buffer_cache.Unmap();
|
// Signal the buffer cache that we are not going to upload more things.
|
||||||
|
const bool invalidate = buffer_cache.Unmap();
|
||||||
|
|
||||||
|
// Now that we are no longer uploading data, we can safely bind the buffers to OpenGL.
|
||||||
|
vertex_array_pushbuffer.Bind();
|
||||||
|
bind_ubo_pushbuffer.Bind();
|
||||||
|
bind_ssbo_pushbuffer.Bind();
|
||||||
|
|
||||||
|
if (invalidate) {
|
||||||
|
// As all cached buffers are invalidated, we need to recheck their state.
|
||||||
|
gpu.dirty_flags.vertex_array.set();
|
||||||
|
}
|
||||||
|
|
||||||
shader_program_manager->ApplyTo(state);
|
shader_program_manager->ApplyTo(state);
|
||||||
state.Apply();
|
state.Apply();
|
||||||
|
@ -675,7 +710,7 @@ void RasterizerOpenGL::FlushRegion(CacheAddr addr, u64 size) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
texture_cache.FlushRegion(addr, size);
|
texture_cache.FlushRegion(addr, size);
|
||||||
global_cache.FlushRegion(addr, size);
|
buffer_cache.FlushRegion(addr, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
void RasterizerOpenGL::InvalidateRegion(CacheAddr addr, u64 size) {
|
void RasterizerOpenGL::InvalidateRegion(CacheAddr addr, u64 size) {
|
||||||
|
@ -685,7 +720,6 @@ void RasterizerOpenGL::InvalidateRegion(CacheAddr addr, u64 size) {
|
||||||
}
|
}
|
||||||
texture_cache.InvalidateRegion(addr, size);
|
texture_cache.InvalidateRegion(addr, size);
|
||||||
shader_cache.InvalidateRegion(addr, size);
|
shader_cache.InvalidateRegion(addr, size);
|
||||||
global_cache.InvalidateRegion(addr, size);
|
|
||||||
buffer_cache.InvalidateRegion(addr, size);
|
buffer_cache.InvalidateRegion(addr, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -696,6 +730,10 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(CacheAddr addr, u64 size) {
|
||||||
InvalidateRegion(addr, size);
|
InvalidateRegion(addr, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void RasterizerOpenGL::TickFrame() {
|
||||||
|
buffer_cache.TickFrame();
|
||||||
|
}
|
||||||
|
|
||||||
bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
const Tegra::Engines::Fermi2D::Config& copy_config) {
|
const Tegra::Engines::Fermi2D::Config& copy_config) {
|
||||||
|
@ -739,11 +777,9 @@ void RasterizerOpenGL::SetupDrawConstBuffers(Tegra::Engines::Maxwell3D::Regs::Sh
|
||||||
MICROPROFILE_SCOPE(OpenGL_UBO);
|
MICROPROFILE_SCOPE(OpenGL_UBO);
|
||||||
const auto stage_index = static_cast<std::size_t>(stage);
|
const auto stage_index = static_cast<std::size_t>(stage);
|
||||||
const auto& shader_stage = system.GPU().Maxwell3D().state.shader_stages[stage_index];
|
const auto& shader_stage = system.GPU().Maxwell3D().state.shader_stages[stage_index];
|
||||||
const auto& entries = shader->GetShaderEntries().const_buffers;
|
|
||||||
|
|
||||||
// Upload only the enabled buffers from the 16 constbuffers of each shader stage
|
// Upload only the enabled buffers from the 16 constbuffers of each shader stage
|
||||||
for (u32 bindpoint = 0; bindpoint < entries.size(); ++bindpoint) {
|
for (const auto& entry : shader->GetShaderEntries().const_buffers) {
|
||||||
const auto& entry = entries[bindpoint];
|
|
||||||
SetupConstBuffer(shader_stage.const_buffers[entry.GetIndex()], entry);
|
SetupConstBuffer(shader_stage.const_buffers[entry.GetIndex()], entry);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -752,46 +788,34 @@ void RasterizerOpenGL::SetupConstBuffer(const Tegra::Engines::ConstBufferInfo& b
|
||||||
const GLShader::ConstBufferEntry& entry) {
|
const GLShader::ConstBufferEntry& entry) {
|
||||||
if (!buffer.enabled) {
|
if (!buffer.enabled) {
|
||||||
// Set values to zero to unbind buffers
|
// Set values to zero to unbind buffers
|
||||||
bind_ubo_pushbuffer.Push(0, 0, 0);
|
bind_ubo_pushbuffer.Push(buffer_cache.GetEmptyBuffer(sizeof(float)), 0, sizeof(float));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::size_t size;
|
|
||||||
if (entry.IsIndirect()) {
|
|
||||||
// Buffer is accessed indirectly, so upload the entire thing
|
|
||||||
size = buffer.size;
|
|
||||||
|
|
||||||
if (size > MaxConstbufferSize) {
|
|
||||||
LOG_WARNING(Render_OpenGL, "Indirect constbuffer size {} exceeds maximum {}", size,
|
|
||||||
MaxConstbufferSize);
|
|
||||||
size = MaxConstbufferSize;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Buffer is accessed directly, upload just what we use
|
|
||||||
size = entry.GetSize();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Align the actual size so it ends up being a multiple of vec4 to meet the OpenGL std140
|
// Align the actual size so it ends up being a multiple of vec4 to meet the OpenGL std140
|
||||||
// UBO alignment requirements.
|
// UBO alignment requirements.
|
||||||
size = Common::AlignUp(size, sizeof(GLvec4));
|
const std::size_t size = Common::AlignUp(GetConstBufferSize(buffer, entry), sizeof(GLvec4));
|
||||||
ASSERT_MSG(size <= MaxConstbufferSize, "Constant buffer is too big");
|
|
||||||
|
|
||||||
const std::size_t alignment = device.GetUniformBufferAlignment();
|
const auto alignment = device.GetUniformBufferAlignment();
|
||||||
const GLintptr offset = buffer_cache.UploadMemory(buffer.address, size, alignment);
|
const auto [cbuf, offset] = buffer_cache.UploadMemory(buffer.address, size, alignment);
|
||||||
bind_ubo_pushbuffer.Push(buffer_cache.GetHandle(), offset, size);
|
bind_ubo_pushbuffer.Push(cbuf, offset, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
void RasterizerOpenGL::SetupGlobalRegions(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage,
|
void RasterizerOpenGL::SetupGlobalRegions(Tegra::Engines::Maxwell3D::Regs::ShaderStage stage,
|
||||||
const Shader& shader) {
|
const Shader& shader) {
|
||||||
const auto& entries = shader->GetShaderEntries().global_memory_entries;
|
auto& gpu{system.GPU()};
|
||||||
for (std::size_t bindpoint = 0; bindpoint < entries.size(); ++bindpoint) {
|
auto& memory_manager{gpu.MemoryManager()};
|
||||||
const auto& entry{entries[bindpoint]};
|
const auto cbufs{gpu.Maxwell3D().state.shader_stages[static_cast<std::size_t>(stage)]};
|
||||||
const auto& region{global_cache.GetGlobalRegion(entry, stage)};
|
const auto alignment{device.GetShaderStorageBufferAlignment()};
|
||||||
if (entry.IsWritten()) {
|
|
||||||
region->MarkAsModified(true, global_cache);
|
for (const auto& entry : shader->GetShaderEntries().global_memory_entries) {
|
||||||
}
|
const auto addr{cbufs.const_buffers[entry.GetCbufIndex()].address + entry.GetCbufOffset()};
|
||||||
bind_ssbo_pushbuffer.Push(region->GetBufferHandle(), 0,
|
const auto actual_addr{memory_manager.Read<u64>(addr)};
|
||||||
static_cast<GLsizeiptr>(region->GetSizeInBytes()));
|
const auto size{memory_manager.Read<u32>(addr + 8)};
|
||||||
|
|
||||||
|
const auto [ssbo, buffer_offset] =
|
||||||
|
buffer_cache.UploadMemory(actual_addr, size, alignment, true, entry.IsWritten());
|
||||||
|
bind_ssbo_pushbuffer.Push(ssbo, buffer_offset, static_cast<GLsizeiptr>(size));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -24,7 +24,6 @@
|
||||||
#include "video_core/renderer_opengl/gl_buffer_cache.h"
|
#include "video_core/renderer_opengl/gl_buffer_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_device.h"
|
#include "video_core/renderer_opengl/gl_device.h"
|
||||||
#include "video_core/renderer_opengl/gl_framebuffer_cache.h"
|
#include "video_core/renderer_opengl/gl_framebuffer_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_global_cache.h"
|
|
||||||
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
||||||
#include "video_core/renderer_opengl/gl_sampler_cache.h"
|
#include "video_core/renderer_opengl/gl_sampler_cache.h"
|
||||||
#include "video_core/renderer_opengl/gl_shader_cache.h"
|
#include "video_core/renderer_opengl/gl_shader_cache.h"
|
||||||
|
@ -63,6 +62,7 @@ public:
|
||||||
void FlushRegion(CacheAddr addr, u64 size) override;
|
void FlushRegion(CacheAddr addr, u64 size) override;
|
||||||
void InvalidateRegion(CacheAddr addr, u64 size) override;
|
void InvalidateRegion(CacheAddr addr, u64 size) override;
|
||||||
void FlushAndInvalidateRegion(CacheAddr addr, u64 size) override;
|
void FlushAndInvalidateRegion(CacheAddr addr, u64 size) override;
|
||||||
|
void TickFrame() override;
|
||||||
bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
const Tegra::Engines::Fermi2D::Config& copy_config) override;
|
const Tegra::Engines::Fermi2D::Config& copy_config) override;
|
||||||
|
@ -73,11 +73,6 @@ public:
|
||||||
void LoadDiskResources(const std::atomic_bool& stop_loading,
|
void LoadDiskResources(const std::atomic_bool& stop_loading,
|
||||||
const VideoCore::DiskResourceLoadCallback& callback) override;
|
const VideoCore::DiskResourceLoadCallback& callback) override;
|
||||||
|
|
||||||
/// Maximum supported size that a constbuffer can have in bytes.
|
|
||||||
static constexpr std::size_t MaxConstbufferSize = 0x10000;
|
|
||||||
static_assert(MaxConstbufferSize % sizeof(GLvec4) == 0,
|
|
||||||
"The maximum size of a constbuffer must be a multiple of the size of GLvec4");
|
|
||||||
|
|
||||||
private:
|
private:
|
||||||
struct FramebufferConfigState {
|
struct FramebufferConfigState {
|
||||||
bool using_color_fb{};
|
bool using_color_fb{};
|
||||||
|
@ -191,7 +186,6 @@ private:
|
||||||
|
|
||||||
TextureCacheOpenGL texture_cache;
|
TextureCacheOpenGL texture_cache;
|
||||||
ShaderCacheOpenGL shader_cache;
|
ShaderCacheOpenGL shader_cache;
|
||||||
GlobalRegionCacheOpenGL global_cache;
|
|
||||||
SamplerCacheOpenGL sampler_cache;
|
SamplerCacheOpenGL sampler_cache;
|
||||||
FramebufferCacheOpenGL framebuffer_cache;
|
FramebufferCacheOpenGL framebuffer_cache;
|
||||||
|
|
||||||
|
@ -210,6 +204,7 @@ private:
|
||||||
static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
|
static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
|
||||||
OGLBufferCache buffer_cache;
|
OGLBufferCache buffer_cache;
|
||||||
|
|
||||||
|
VertexArrayPushBuffer vertex_array_pushbuffer;
|
||||||
BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
|
BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
|
||||||
BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};
|
BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};
|
||||||
|
|
||||||
|
@ -222,7 +217,9 @@ private:
|
||||||
|
|
||||||
void SetupVertexBuffer(GLuint vao);
|
void SetupVertexBuffer(GLuint vao);
|
||||||
|
|
||||||
DrawParameters SetupDraw();
|
GLintptr SetupIndexBuffer();
|
||||||
|
|
||||||
|
DrawParameters SetupDraw(GLintptr index_buffer_offset);
|
||||||
|
|
||||||
void SetupShaders(GLenum primitive_mode);
|
void SetupShaders(GLenum primitive_mode);
|
||||||
|
|
||||||
|
|
|
@ -46,7 +46,7 @@ using TextureArgument = std::pair<Type, Node>;
|
||||||
using TextureIR = std::variant<TextureAoffi, TextureArgument>;
|
using TextureIR = std::variant<TextureAoffi, TextureArgument>;
|
||||||
|
|
||||||
constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
|
constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
|
||||||
static_cast<u32>(RasterizerOpenGL::MaxConstbufferSize) / (4 * sizeof(float));
|
static_cast<u32>(Maxwell::MaxConstBufferSize) / (4 * sizeof(float));
|
||||||
|
|
||||||
class ShaderWriter {
|
class ShaderWriter {
|
||||||
public:
|
public:
|
||||||
|
|
|
@ -101,7 +101,6 @@ RendererOpenGL::RendererOpenGL(Core::Frontend::EmuWindow& emu_window, Core::Syst
|
||||||
|
|
||||||
RendererOpenGL::~RendererOpenGL() = default;
|
RendererOpenGL::~RendererOpenGL() = default;
|
||||||
|
|
||||||
/// Swap buffers (render frame)
|
|
||||||
void RendererOpenGL::SwapBuffers(
|
void RendererOpenGL::SwapBuffers(
|
||||||
std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) {
|
std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) {
|
||||||
|
|
||||||
|
@ -130,6 +129,8 @@ void RendererOpenGL::SwapBuffers(
|
||||||
|
|
||||||
DrawScreen(render_window.GetFramebufferLayout());
|
DrawScreen(render_window.GetFramebufferLayout());
|
||||||
|
|
||||||
|
rasterizer->TickFrame();
|
||||||
|
|
||||||
render_window.SwapBuffers();
|
render_window.SwapBuffers();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -262,7 +263,6 @@ void RendererOpenGL::CreateRasterizer() {
|
||||||
if (rasterizer) {
|
if (rasterizer) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
// Initialize sRGB Usage
|
|
||||||
OpenGLState::ClearsRGBUsed();
|
OpenGLState::ClearsRGBUsed();
|
||||||
rasterizer = std::make_unique<RasterizerOpenGL>(system, emu_window, screen_info);
|
rasterizer = std::make_unique<RasterizerOpenGL>(system, emu_window, screen_info);
|
||||||
}
|
}
|
||||||
|
|
|
@ -13,29 +13,67 @@
|
||||||
|
|
||||||
namespace OpenGL {
|
namespace OpenGL {
|
||||||
|
|
||||||
|
VertexArrayPushBuffer::VertexArrayPushBuffer() = default;
|
||||||
|
|
||||||
|
VertexArrayPushBuffer::~VertexArrayPushBuffer() = default;
|
||||||
|
|
||||||
|
void VertexArrayPushBuffer::Setup(GLuint vao_) {
|
||||||
|
vao = vao_;
|
||||||
|
index_buffer = nullptr;
|
||||||
|
vertex_buffers.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
void VertexArrayPushBuffer::SetIndexBuffer(const GLuint* buffer) {
|
||||||
|
index_buffer = buffer;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VertexArrayPushBuffer::SetVertexBuffer(GLuint binding_index, const GLuint* buffer,
|
||||||
|
GLintptr offset, GLsizei stride) {
|
||||||
|
vertex_buffers.push_back(Entry{binding_index, buffer, offset, stride});
|
||||||
|
}
|
||||||
|
|
||||||
|
void VertexArrayPushBuffer::Bind() {
|
||||||
|
if (index_buffer) {
|
||||||
|
glVertexArrayElementBuffer(vao, *index_buffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(Rodrigo): Find a way to ARB_multi_bind this
|
||||||
|
for (const auto& entry : vertex_buffers) {
|
||||||
|
glVertexArrayVertexBuffer(vao, entry.binding_index, *entry.buffer, entry.offset,
|
||||||
|
entry.stride);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
BindBuffersRangePushBuffer::BindBuffersRangePushBuffer(GLenum target) : target{target} {}
|
BindBuffersRangePushBuffer::BindBuffersRangePushBuffer(GLenum target) : target{target} {}
|
||||||
|
|
||||||
BindBuffersRangePushBuffer::~BindBuffersRangePushBuffer() = default;
|
BindBuffersRangePushBuffer::~BindBuffersRangePushBuffer() = default;
|
||||||
|
|
||||||
void BindBuffersRangePushBuffer::Setup(GLuint first_) {
|
void BindBuffersRangePushBuffer::Setup(GLuint first_) {
|
||||||
first = first_;
|
first = first_;
|
||||||
buffers.clear();
|
buffer_pointers.clear();
|
||||||
offsets.clear();
|
offsets.clear();
|
||||||
sizes.clear();
|
sizes.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
void BindBuffersRangePushBuffer::Push(GLuint buffer, GLintptr offset, GLsizeiptr size) {
|
void BindBuffersRangePushBuffer::Push(const GLuint* buffer, GLintptr offset, GLsizeiptr size) {
|
||||||
buffers.push_back(buffer);
|
buffer_pointers.push_back(buffer);
|
||||||
offsets.push_back(offset);
|
offsets.push_back(offset);
|
||||||
sizes.push_back(size);
|
sizes.push_back(size);
|
||||||
}
|
}
|
||||||
|
|
||||||
void BindBuffersRangePushBuffer::Bind() const {
|
void BindBuffersRangePushBuffer::Bind() {
|
||||||
const std::size_t count{buffers.size()};
|
// Ensure sizes are valid.
|
||||||
|
const std::size_t count{buffer_pointers.size()};
|
||||||
DEBUG_ASSERT(count == offsets.size() && count == sizes.size());
|
DEBUG_ASSERT(count == offsets.size() && count == sizes.size());
|
||||||
if (count == 0) {
|
if (count == 0) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Dereference buffers.
|
||||||
|
buffers.resize(count);
|
||||||
|
std::transform(buffer_pointers.begin(), buffer_pointers.end(), buffers.begin(),
|
||||||
|
[](const GLuint* pointer) { return *pointer; });
|
||||||
|
|
||||||
glBindBuffersRange(target, first, static_cast<GLsizei>(count), buffers.data(), offsets.data(),
|
glBindBuffersRange(target, first, static_cast<GLsizei>(count), buffers.data(), offsets.data(),
|
||||||
sizes.data());
|
sizes.data());
|
||||||
}
|
}
|
||||||
|
|
|
@ -11,20 +11,49 @@
|
||||||
|
|
||||||
namespace OpenGL {
|
namespace OpenGL {
|
||||||
|
|
||||||
class BindBuffersRangePushBuffer {
|
class VertexArrayPushBuffer final {
|
||||||
public:
|
public:
|
||||||
BindBuffersRangePushBuffer(GLenum target);
|
explicit VertexArrayPushBuffer();
|
||||||
|
~VertexArrayPushBuffer();
|
||||||
|
|
||||||
|
void Setup(GLuint vao_);
|
||||||
|
|
||||||
|
void SetIndexBuffer(const GLuint* buffer);
|
||||||
|
|
||||||
|
void SetVertexBuffer(GLuint binding_index, const GLuint* buffer, GLintptr offset,
|
||||||
|
GLsizei stride);
|
||||||
|
|
||||||
|
void Bind();
|
||||||
|
|
||||||
|
private:
|
||||||
|
struct Entry {
|
||||||
|
GLuint binding_index{};
|
||||||
|
const GLuint* buffer{};
|
||||||
|
GLintptr offset{};
|
||||||
|
GLsizei stride{};
|
||||||
|
};
|
||||||
|
|
||||||
|
GLuint vao{};
|
||||||
|
const GLuint* index_buffer{};
|
||||||
|
std::vector<Entry> vertex_buffers;
|
||||||
|
};
|
||||||
|
|
||||||
|
class BindBuffersRangePushBuffer final {
|
||||||
|
public:
|
||||||
|
explicit BindBuffersRangePushBuffer(GLenum target);
|
||||||
~BindBuffersRangePushBuffer();
|
~BindBuffersRangePushBuffer();
|
||||||
|
|
||||||
void Setup(GLuint first_);
|
void Setup(GLuint first_);
|
||||||
|
|
||||||
void Push(GLuint buffer, GLintptr offset, GLsizeiptr size);
|
void Push(const GLuint* buffer, GLintptr offset, GLsizeiptr size);
|
||||||
|
|
||||||
void Bind() const;
|
void Bind();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
GLenum target;
|
GLenum target{};
|
||||||
GLuint first;
|
GLuint first{};
|
||||||
|
std::vector<const GLuint*> buffer_pointers;
|
||||||
|
|
||||||
std::vector<GLuint> buffers;
|
std::vector<GLuint> buffers;
|
||||||
std::vector<GLintptr> offsets;
|
std::vector<GLintptr> offsets;
|
||||||
std::vector<GLsizeiptr> sizes;
|
std::vector<GLsizeiptr> sizes;
|
||||||
|
|
Reference in New Issue