omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Share retained sampler and pixel-buffer dispatch bridges

Browse Source
This commit is contained in:
omigamedev
2026-06-05 14:42:40 +02:00
parent 84e63c0d34
commit d719a5a5e5
7 changed files with 294 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
src/legacy_gl_pixel_buffer_dispatch.h Normal file
View File

@@ -0,0 +1,96 @@
#pragma once
#include <cstdint>
#include "legacy_gl_framebuffer_dispatch.h"
#include "renderer_gl/opengl_capabilities.h"
namespace pp::legacy::gl_pixel_buffer {
inline void gen_opengl_buffers(std::uint32_t count, std::uint32_t* ids) noexcept
{
glGenBuffers(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
}
inline void delete_opengl_buffers(std::uint32_t count, const std::uint32_t* ids) noexcept
{
glDeleteBuffers(static_cast<GLsizei>(count), reinterpret_cast<const GLuint*>(ids));
}
inline void bind_opengl_buffer(std::uint32_t target, std::uint32_t buffer) noexcept
{
glBindBuffer(static_cast<GLenum>(target), static_cast<GLuint>(buffer));
}
inline void set_opengl_buffer_data(
std::uint32_t target,
std::intptr_t byte_count,
const void* data,
std::uint32_t usage) noexcept
{
glBufferData(
static_cast<GLenum>(target),
static_cast<GLsizeiptr>(byte_count),
data,
static_cast<GLenum>(usage));
}
inline void* map_opengl_buffer_range(
std::uint32_t target,
std::intptr_t offset,
std::intptr_t byte_count,
std::uint32_t access) noexcept
{
return glMapBufferRange(
static_cast<GLenum>(target),
static_cast<GLintptr>(offset),
static_cast<GLsizeiptr>(byte_count),
static_cast<GLbitfield>(access));
}
inline void unmap_opengl_buffer(std::uint32_t target) noexcept
{
glUnmapBuffer(static_cast<GLenum>(target));
}
inline pp::renderer::gl::OpenGlPixelBufferAllocationDispatch pixel_buffer_allocation_dispatch() noexcept
{
return pp::renderer::gl::OpenGlPixelBufferAllocationDispatch {
.gen_buffers = gen_opengl_buffers,
};
}
inline pp::renderer::gl::OpenGlPixelBufferReadbackDispatch pixel_buffer_readback_dispatch() noexcept
{
return pp::renderer::gl::OpenGlPixelBufferReadbackDispatch {
.gen_buffers = gen_opengl_buffers,
.bind_buffer = bind_opengl_buffer,
.buffer_data = set_opengl_buffer_data,
.read_pixels = pp::legacy::gl_framebuffer::read_opengl_pixels,
};
}
inline pp::renderer::gl::OpenGlPixelBufferMapDispatch pixel_buffer_map_dispatch() noexcept
{
return pp::renderer::gl::OpenGlPixelBufferMapDispatch {
.bind_buffer = bind_opengl_buffer,
.map_buffer_range = map_opengl_buffer_range,
};
}
inline pp::renderer::gl::OpenGlPixelBufferUnmapDispatch pixel_buffer_unmap_dispatch() noexcept
{
return pp::renderer::gl::OpenGlPixelBufferUnmapDispatch {
.bind_buffer = bind_opengl_buffer,
.unmap_buffer = unmap_opengl_buffer,
};
}
inline pp::renderer::gl::OpenGlPixelBufferDeleteDispatch pixel_buffer_delete_dispatch() noexcept
{
return pp::renderer::gl::OpenGlPixelBufferDeleteDispatch {
.delete_buffers = delete_opengl_buffers,
};
}
} // namespace pp::legacy::gl_pixel_buffer

154
src/legacy_gl_sampler_dispatch.h Normal file
View File

@@ -0,0 +1,154 @@
#pragma once
#include <cstdint>
#include <span>
#include "log.h"
#include "renderer_gl/opengl_capabilities.h"
namespace pp::legacy::gl_sampler {
inline void gen_opengl_samplers(std::uint32_t count, std::uint32_t* ids) noexcept
{
#if USE_SAMPLER
glGenSamplers(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
#else
for (std::uint32_t i = 0U; i < count; ++i) {
ids[i] = 0U;
}
#endif
}
inline void set_opengl_sampler_parameter_i(
std::uint32_t sampler,
std::uint32_t parameter,
std::int32_t value) noexcept
{
#if USE_SAMPLER
glSamplerParameteri(
static_cast<GLuint>(sampler),
static_cast<GLenum>(parameter),
static_cast<GLint>(value));
#else
(void)sampler;
(void)parameter;
(void)value;
#endif
}
inline void set_opengl_sampler_parameter_fv(
std::uint32_t sampler,
std::uint32_t parameter,
const float* values) noexcept
{
#if USE_SAMPLER && !defined(__GLES__)
glSamplerParameterfv(
static_cast<GLuint>(sampler),
static_cast<GLenum>(parameter),
values);
#else
(void)sampler;
(void)parameter;
(void)values;
#endif
}
inline void bind_opengl_sampler(std::uint32_t unit, std::uint32_t sampler) noexcept
{
#if USE_SAMPLER
glBindSampler(static_cast<GLuint>(unit), static_cast<GLuint>(sampler));
#else
(void)unit;
(void)sampler;
#endif
}
inline pp::renderer::gl::OpenGlSamplerCreateDispatch sampler_create_dispatch() noexcept
{
return pp::renderer::gl::OpenGlSamplerCreateDispatch {
.gen_samplers = gen_opengl_samplers,
.sampler_parameter_i = set_opengl_sampler_parameter_i,
};
}
inline pp::renderer::gl::OpenGlSamplerParameterDispatch sampler_parameter_dispatch() noexcept
{
return pp::renderer::gl::OpenGlSamplerParameterDispatch {
.sampler_parameter_i = set_opengl_sampler_parameter_i,
};
}
inline pp::renderer::gl::OpenGlSamplerBorderDispatch sampler_border_dispatch() noexcept
{
return pp::renderer::gl::OpenGlSamplerBorderDispatch {
.sampler_parameter_fv = set_opengl_sampler_parameter_fv,
};
}
inline pp::renderer::gl::OpenGlSamplerBindDispatch sampler_bind_dispatch() noexcept
{
return pp::renderer::gl::OpenGlSamplerBindDispatch {
.bind_sampler = bind_opengl_sampler,
};
}
inline std::uint32_t create_sampler(
std::span<const pp::renderer::gl::OpenGlTextureParameter> parameters,
const char* context)
{
const auto result = pp::renderer::gl::create_opengl_sampler(parameters, sampler_create_dispatch());
if (!result.ok()) {
LOG("%s failed because: %s", context, result.status().message);
return 0U;
}
return result.value();
}
inline bool set_sampler_parameters(
std::uint32_t sampler_id,
std::span<const pp::renderer::gl::OpenGlTextureParameter> parameters,
const char* context)
{
const auto status = pp::renderer::gl::set_opengl_sampler_parameters(
sampler_id,
parameters,
sampler_parameter_dispatch());
if (!status.ok()) {
LOG("%s failed because: %s", context, status.message);
return false;
}
return true;
}
inline bool set_sampler_border_color(
std::uint32_t sampler_id,
std::uint32_t parameter,
const float* rgba,
const char* context)
{
const auto status = pp::renderer::gl::set_opengl_sampler_border_color(
sampler_id,
parameter,
rgba,
sampler_border_dispatch());
if (!status.ok()) {
LOG("%s failed because: %s", context, status.message);
return false;
}
return true;
}
inline bool bind_sampler(std::uint32_t unit, std::uint32_t sampler_id, const char* context)
{
const auto status = pp::renderer::gl::bind_opengl_sampler_object(
unit,
sampler_id,
sampler_bind_dispatch());
if (!status.ok()) {
LOG("%s failed because: %s", context, status.message);
return false;
}
return true;
}
} // namespace pp::legacy::gl_sampler

90
src/rtt.cpp
View File

@@ -4,6 +4,7 @@
#include "util.h"
#include "app.h"
#include "legacy_gl_framebuffer_dispatch.h"
#include "legacy_gl_pixel_buffer_dispatch.h"
#include "legacy_gl_renderbuffer_dispatch.h"
#include "legacy_gl_texture_dispatch.h"
#include "renderer_gl/opengl_capabilities.h"
@@ -32,52 +33,6 @@ void set_opengl_color_mask(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::
glColorMask(r, g, b, a);
}
void gen_opengl_buffers(std::uint32_t count, std::uint32_t* ids) noexcept
{
glGenBuffers(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
}
void delete_opengl_buffers(std::uint32_t count, const std::uint32_t* ids) noexcept
{
glDeleteBuffers(static_cast<GLsizei>(count), reinterpret_cast<const GLuint*>(ids));
}
void bind_opengl_buffer(std::uint32_t target, std::uint32_t buffer) noexcept
{
glBindBuffer(static_cast<GLenum>(target), static_cast<GLuint>(buffer));
}
void set_opengl_buffer_data(
std::uint32_t target,
std::intptr_t byte_count,
const void* data,
std::uint32_t usage) noexcept
{
glBufferData(
static_cast<GLenum>(target),
static_cast<GLsizeiptr>(byte_count),
data,
static_cast<GLenum>(usage));
}
void* map_opengl_buffer_range(
std::uint32_t target,
std::intptr_t offset,
std::intptr_t byte_count,
std::uint32_t access) noexcept
{
return glMapBufferRange(
static_cast<GLenum>(target),
static_cast<GLintptr>(offset),
static_cast<GLsizeiptr>(byte_count),
static_cast<GLbitfield>(access));
}
void unmap_opengl_buffer(std::uint32_t target) noexcept
{
glUnmapBuffer(static_cast<GLenum>(target));
}
}
RTT& RTT::operator=(RTT&& other)
@@ -686,9 +641,7 @@ bool PBO::create() noexcept
{
App::I->render_task([this] {
const auto result = pp::renderer::gl::allocate_opengl_pixel_buffer(
pp::renderer::gl::OpenGlPixelBufferAllocationDispatch {
.gen_buffers = gen_opengl_buffers,
});
pp::legacy::gl_pixel_buffer::pixel_buffer_allocation_dispatch());
if (!result.ok()) {
LOG("%s", result.status().message);
buffer_id = 0U;
@@ -709,12 +662,7 @@ bool PBO::create(RTT& rtt) noexcept
width,
height,
pp::renderer::gl::rgba8_readback_format(),
pp::renderer::gl::OpenGlPixelBufferReadbackDispatch {
.gen_buffers = gen_opengl_buffers,
.bind_buffer = bind_opengl_buffer,
.buffer_data = set_opengl_buffer_data,
.read_pixels = pp::legacy::gl_framebuffer::read_opengl_pixels,
});
pp::legacy::gl_pixel_buffer::pixel_buffer_readback_dispatch());
rtt.unbindFramebuffer();
if (!result.ok()) {
LOG("%s", result.status().message);
@@ -733,9 +681,7 @@ void PBO::destroy() noexcept
App::I->render_task_async([id=buffer_id] {
const auto status = pp::renderer::gl::delete_opengl_pixel_buffer(
id,
pp::renderer::gl::OpenGlPixelBufferDeleteDispatch {
.delete_buffers = delete_opengl_buffers,
});
pp::legacy::gl_pixel_buffer::pixel_buffer_delete_dispatch());
if (!status.ok()) {
LOG("%s", status.message);
}
@@ -748,24 +694,6 @@ void PBO::destroy() noexcept
}
}
/*
void PBO::bind_read() noexcept
{
App::I->render_task([this] {
const auto buffer_target = static_cast<GLenum>(pp::renderer::gl::pixel_unpack_buffer_target());
glBindBuffer(buffer_target, buffer_id);
bound_slot = buffer_target;
});
}
void PBO::unbind() noexcept
{
App::I->render_task([this] {
glBindBuffer(bound_slot, buffer_id);
});
}
*/
glm::uint8_t* PBO::map() noexcept
{
App::I->render_task([this] {
@@ -774,10 +702,7 @@ glm::uint8_t* PBO::map() noexcept
width,
height,
pp::renderer::gl::rgba8_readback_format(),
pp::renderer::gl::OpenGlPixelBufferMapDispatch {
.bind_buffer = bind_opengl_buffer,
.map_buffer_range = map_opengl_buffer_range,
});
pp::legacy::gl_pixel_buffer::pixel_buffer_map_dispatch());
if (!result.ok()) {
LOG("%s", result.status().message);
mapped_ptr = nullptr;
@@ -793,10 +718,7 @@ void PBO::unmap() noexcept
App::I->render_task([this] {
const auto status = pp::renderer::gl::unmap_opengl_pixel_buffer(
buffer_id,
pp::renderer::gl::OpenGlPixelBufferUnmapDispatch {
.bind_buffer = bind_opengl_buffer,
.unmap_buffer = unmap_opengl_buffer,
});
pp::legacy::gl_pixel_buffer::pixel_buffer_unmap_dispatch());
if (!status.ok()) {
LOG("%s", status.message);
}

112
src/texture.cpp
View File

@@ -4,70 +4,12 @@
#include "util.h"
#include "app.h"
#include "legacy_gl_framebuffer_dispatch.h"
#include "legacy_gl_sampler_dispatch.h"
#include "legacy_gl_texture_dispatch.h"
#include "renderer_gl/opengl_capabilities.h"
#include <cstdint>
namespace {
void gen_opengl_samplers(std::uint32_t count, std::uint32_t* ids) noexcept
{
#if USE_SAMPLER
glGenSamplers(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
#else
for (std::uint32_t i = 0U; i < count; ++i) {
ids[i] = 0U;
}
#endif
}
void set_opengl_sampler_parameter_i(
std::uint32_t sampler,
std::uint32_t parameter,
std::int32_t value) noexcept
{
#if USE_SAMPLER
glSamplerParameteri(
static_cast<GLuint>(sampler),
static_cast<GLenum>(parameter),
static_cast<GLint>(value));
#else
(void)sampler;
(void)parameter;
(void)value;
#endif
}
void set_opengl_sampler_parameter_fv(
std::uint32_t sampler,
std::uint32_t parameter,
const float* values) noexcept
{
#if USE_SAMPLER && !defined(__GLES__)
glSamplerParameterfv(
static_cast<GLuint>(sampler),
static_cast<GLenum>(parameter),
values);
#else
(void)sampler;
(void)parameter;
(void)values;
#endif
}
void bind_opengl_sampler(std::uint32_t unit, std::uint32_t sampler) noexcept
{
#if USE_SAMPLER
glBindSampler(static_cast<GLuint>(unit), static_cast<GLuint>(sampler));
#else
(void)unit;
(void)sampler;
#endif
}
}
std::map<uint16_t, Texture2D> TextureManager::m_textures;
std::array<int, 6> TextureCube::m_faces_map {
static_cast<int>(pp::renderer::gl::cube_face_texture_target(0U)),
@@ -419,19 +361,15 @@ bool Sampler::create(GLint filter, GLint wrap)
const auto parameters = pp::renderer::gl::sampler_parameters_for_filter_wrap(
static_cast<std::uint32_t>(filter),
static_cast<std::uint32_t>(wrap));
const auto sampler = pp::renderer::gl::create_opengl_sampler(
const auto sampler = pp::legacy::gl_sampler::create_sampler(
parameters,
pp::renderer::gl::OpenGlSamplerCreateDispatch {
.gen_samplers = gen_opengl_samplers,
.sampler_parameter_i = set_opengl_sampler_parameter_i,
});
if (!sampler.ok())
"Sampler::create()");
if (sampler == 0U)
{
ret = false;
LOG("Sampler::create() failed because: %s", sampler.status().message);
return;
}
id = static_cast<GLuint>(sampler.value());
id = static_cast<GLuint>(sampler);
ret = true;
});
return ret;
@@ -456,14 +394,10 @@ void Sampler::set(GLint filter, GLint wrap)
const auto parameters = pp::renderer::gl::sampler_parameters_for_filter_wrap(
static_cast<std::uint32_t>(filter),
static_cast<std::uint32_t>(wrap));
const auto status = pp::renderer::gl::set_opengl_sampler_parameters(
pp::legacy::gl_sampler::set_sampler_parameters(
static_cast<std::uint32_t>(id),
parameters,
pp::renderer::gl::OpenGlSamplerParameterDispatch {
.sampler_parameter_i = set_opengl_sampler_parameter_i,
});
if (!status.ok())
LOG("Sampler::set() failed because: %s", status.message);
"Sampler::set()");
});
}
@@ -486,54 +420,38 @@ void Sampler::set_filter(GLint filter_min, GLint filter_mag)
const auto parameters = pp::renderer::gl::sampler_filter_parameters(
static_cast<std::uint32_t>(filter_min),
static_cast<std::uint32_t>(filter_mag));
const auto status = pp::renderer::gl::set_opengl_sampler_parameters(
pp::legacy::gl_sampler::set_sampler_parameters(
static_cast<std::uint32_t>(id),
parameters,
pp::renderer::gl::OpenGlSamplerParameterDispatch {
.sampler_parameter_i = set_opengl_sampler_parameter_i,
});
if (!status.ok())
LOG("Sampler::set_filter() failed because: %s", status.message);
"Sampler::set_filter()");
});
}
void Sampler::set_border(glm::vec4 rgba)
{
App::I->render_task([this, rgba]
{
const auto status = pp::renderer::gl::set_opengl_sampler_border_color(
pp::legacy::gl_sampler::set_sampler_border_color(
static_cast<std::uint32_t>(id),
pp::renderer::gl::sampler_border_color_parameter_name(),
glm::value_ptr(rgba),
pp::renderer::gl::OpenGlSamplerBorderDispatch {
.sampler_parameter_fv = set_opengl_sampler_parameter_fv,
});
if (!status.ok())
LOG("Sampler::set_border() failed because: %s", status.message);
"Sampler::set_border()");
});
}
void Sampler::bind(int unit) const
{
assert(App::I->is_render_thread());
current_unit = unit;
const auto status = pp::renderer::gl::bind_opengl_sampler_object(
pp::legacy::gl_sampler::bind_sampler(
static_cast<std::uint32_t>(unit),
static_cast<std::uint32_t>(id),
pp::renderer::gl::OpenGlSamplerBindDispatch {
.bind_sampler = bind_opengl_sampler,
});
if (!status.ok())
LOG("Sampler::bind() failed because: %s", status.message);
"Sampler::bind()");
}
void Sampler::unbind()
{
assert(App::I->is_render_thread());
const auto status = pp::renderer::gl::bind_opengl_sampler_object(
pp::legacy::gl_sampler::bind_sampler(
static_cast<std::uint32_t>(current_unit),
0U,
pp::renderer::gl::OpenGlSamplerBindDispatch {
.bind_sampler = bind_opengl_sampler,
});
if (!status.ok())
LOG("Sampler::unbind() failed because: %s", status.message);
"Sampler::unbind()");
}