tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] add generic base class for renderbuffers

Browse Source
This commit is contained in:
Konstantin Käfer
2019-03-20 15:27:13 +01:00
parent 839f4687aa
commit be3b5917c1
13 changed files with 134 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
platform/default/src/mbgl/gl/headless_backend.cpp
View File

@@ -16,8 +16,8 @@ public:
framebuffer(context.createFramebuffer(color, depthStencil)) {
}
gl::Renderbuffer<gfx::RenderbufferPixelType::RGBA> color;
gl::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil> depthStencil;
gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA> color;
gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil> depthStencil;
gl::Framebuffer framebuffer;
};

3
src/core-files.json
View File

@@ -519,6 +519,7 @@
"mbgl/gfx/index_buffer.hpp": "src/mbgl/gfx/index_buffer.hpp",
"mbgl/gfx/index_vector.hpp": "src/mbgl/gfx/index_vector.hpp",
"mbgl/gfx/program.hpp": "src/mbgl/gfx/program.hpp",
"mbgl/gfx/renderbuffer.hpp": "src/mbgl/gfx/renderbuffer.hpp",
"mbgl/gfx/stencil_mode.hpp": "src/mbgl/gfx/stencil_mode.hpp",
"mbgl/gfx/texture.hpp": "src/mbgl/gfx/texture.hpp",
"mbgl/gfx/types.hpp": "src/mbgl/gfx/types.hpp",
@@ -540,7 +541,7 @@
"mbgl/gl/object.hpp": "src/mbgl/gl/object.hpp",
"mbgl/gl/program.hpp": "src/mbgl/gl/program.hpp",
"mbgl/gl/program_binary_extension.hpp": "src/mbgl/gl/program_binary_extension.hpp",
"mbgl/gl/renderbuffer.hpp": "src/mbgl/gl/renderbuffer.hpp",
"mbgl/gl/renderbuffer_resource.hpp": "src/mbgl/gl/renderbuffer_resource.hpp",
"mbgl/gl/state.hpp": "src/mbgl/gl/state.hpp",
"mbgl/gl/texture.hpp": "src/mbgl/gl/texture.hpp",
"mbgl/gl/texture_resource.hpp": "src/mbgl/gl/texture_resource.hpp",

12
src/mbgl/gfx/context.hpp
View File

@@ -5,6 +5,7 @@
#include <mbgl/gfx/index_vector.hpp>
#include <mbgl/gfx/index_buffer.hpp>
#include <mbgl/gfx/texture.hpp>
#include <mbgl/gfx/renderbuffer.hpp>
#include <mbgl/gfx/draw_scope.hpp>
#include <mbgl/gfx/program.hpp>
#include <mbgl/gfx/types.hpp>
@@ -120,6 +121,17 @@ protected:
virtual void updateTextureResourceSub(const TextureResource&, uint16_t xOffset, uint16_t yOffset, Size, const void* data,
TexturePixelType, TextureChannelDataType) = 0;
public:
template <RenderbufferPixelType pixelType>
Renderbuffer<pixelType>
createRenderbuffer(const Size size) {
return { size, createRenderbufferResource(pixelType, size) };
}
protected:
virtual std::unique_ptr<RenderbufferResource>
createRenderbufferResource(RenderbufferPixelType, Size) = 0;
public:
DrawScope createDrawScope() {
return { createDrawScopeResource() };

52
src/mbgl/gfx/renderbuffer.hpp Normal file
View File

@@ -0,0 +1,52 @@
#pragma once
#include <mbgl/gfx/types.hpp>
#include <mbgl/util/size.hpp>
#include <memory>
#include <cassert>
namespace mbgl {
namespace gfx {
class RenderbufferResource {
protected:
RenderbufferResource() = default;
public:
virtual ~RenderbufferResource() = default;
};
template <RenderbufferPixelType renderbufferType>
class Renderbuffer final {
public:
Renderbuffer(const Size size_, std::unique_ptr<RenderbufferResource> resource_)
: size(size_), resource(std::move(resource_)) {
}
void setShouldClear(bool clear) {
dirty = clear;
}
bool needsClearing() const {
return dirty;
}
const Size& getSize() const {
return size;
}
template <typename T = RenderbufferResource>
T& getResource() const {
assert(resource);
return static_cast<T&>(*resource);
}
protected:
Size size;
bool dirty = false;
std::unique_ptr<RenderbufferResource> resource;
};
} // namespace gfx
} // namespace mbgl

49
src/mbgl/gl/context.cpp
View File

@@ -3,6 +3,7 @@
#include <mbgl/gl/vertex_buffer_resource.hpp>
#include <mbgl/gl/index_buffer_resource.hpp>
#include <mbgl/gl/texture_resource.hpp>
#include <mbgl/gl/renderbuffer_resource.hpp>
#include <mbgl/gl/draw_scope_resource.hpp>
#include <mbgl/gl/texture.hpp>
#include <mbgl/gl/debugging.hpp>
@@ -336,7 +337,8 @@ UniqueFramebuffer Context::createFramebuffer() {
return UniqueFramebuffer{ std::move(id), { this } };
}
UniqueRenderbuffer Context::createRenderbuffer(const gfx::RenderbufferPixelType type, const Size size) {
std::unique_ptr<gfx::RenderbufferResource>
Context::createRenderbufferResource(const gfx::RenderbufferPixelType type, const Size size) {
RenderbufferID id = 0;
MBGL_CHECK_ERROR(glGenRenderbuffers(1, &id));
UniqueRenderbuffer renderbuffer{ std::move(id), { this } };
@@ -345,9 +347,10 @@ UniqueRenderbuffer Context::createRenderbuffer(const gfx::RenderbufferPixelType
MBGL_CHECK_ERROR(
glRenderbufferStorage(GL_RENDERBUFFER, Enum<gfx::RenderbufferPixelType>::to(type), size.width, size.height));
bindRenderbuffer = 0;
return renderbuffer;
return std::make_unique<gl::RenderbufferResource>(std::move(renderbuffer));
}
std::unique_ptr<uint8_t[]> Context::readFramebuffer(const Size size, const gfx::TexturePixelType format, const bool flip) {
const size_t stride = size.width * (format == gfx::TexturePixelType::RGBA ? 4 : 1);
auto data = std::make_unique<uint8_t[]>(stride * size.height);
@@ -417,48 +420,52 @@ void checkFramebuffer() {
}
void bindDepthStencilRenderbuffer(
const Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
const gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
auto& depthStencilResource = depthStencil.getResource<gl::RenderbufferResource>();
#ifdef GL_DEPTH_STENCIL_ATTACHMENT
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, depthStencil.renderbuffer));
GL_RENDERBUFFER, depthStencilResource.renderbuffer));
#else
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
depthStencil.renderbuffer));
depthStencilResource.renderbuffer));
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, depthStencil.renderbuffer));
GL_RENDERBUFFER, depthStencilResource.renderbuffer));
#endif
}
} // namespace
Framebuffer
Context::createFramebuffer(const Renderbuffer<gfx::RenderbufferPixelType::RGBA>& color,
const Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
if (color.size != depthStencil.size) {
Context::createFramebuffer(const gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA>& color,
const gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
if (color.getSize() != depthStencil.getSize()) {
throw std::runtime_error("Renderbuffer size mismatch");
}
auto fbo = createFramebuffer();
bindFramebuffer = fbo;
auto& colorResource = color.getResource<gl::RenderbufferResource>();
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, color.renderbuffer));
GL_RENDERBUFFER, colorResource.renderbuffer));
bindDepthStencilRenderbuffer(depthStencil);
checkFramebuffer();
return { color.size, std::move(fbo) };
return { color.getSize(), std::move(fbo) };
}
Framebuffer Context::createFramebuffer(const Renderbuffer<gfx::RenderbufferPixelType::RGBA>& color) {
Framebuffer Context::createFramebuffer(const gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA>& color) {
auto fbo = createFramebuffer();
bindFramebuffer = fbo;
auto& colorResource = color.getResource<gl::RenderbufferResource>();
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, color.renderbuffer));
GL_RENDERBUFFER, colorResource.renderbuffer));
checkFramebuffer();
return { color.size, std::move(fbo) };
return { color.getSize(), std::move(fbo) };
}
Framebuffer
Context::createFramebuffer(const gfx::Texture& color,
const Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
if (color.size != depthStencil.size) {
const gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>& depthStencil) {
if (color.size != depthStencil.getSize()) {
throw std::runtime_error("Renderbuffer size mismatch");
}
auto fbo = createFramebuffer();
@@ -483,8 +490,8 @@ Framebuffer Context::createFramebuffer(const gfx::Texture& color) {
Framebuffer
Context::createFramebuffer(const gfx::Texture& color,
const Renderbuffer<gfx::RenderbufferPixelType::Depth>& depthTarget) {
if (color.size != depthTarget.size) {
const gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>& depth) {
if (color.size != depth.getSize()) {
throw std::runtime_error("Renderbuffer size mismatch");
}
auto fbo = createFramebuffer();
@@ -492,10 +499,12 @@ Context::createFramebuffer(const gfx::Texture& color,
MBGL_CHECK_ERROR(glFramebufferTexture2D(
GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
reinterpret_cast<const gl::TextureResource&>(*color.resource).texture, 0));
auto& depthResource = depth.getResource<gl::RenderbufferResource>();
MBGL_CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
depthTarget.renderbuffer));
depthResource.renderbuffer));
checkFramebuffer();
return { depthTarget.size, std::move(fbo) };
return { depth.getSize(), std::move(fbo) };
}
std::unique_ptr<gfx::TextureResource>

23
src/mbgl/gl/context.hpp
View File

@@ -5,7 +5,6 @@
#include <mbgl/gl/object.hpp>
#include <mbgl/gl/state.hpp>
#include <mbgl/gl/value.hpp>
#include <mbgl/gl/renderbuffer.hpp>
#include <mbgl/gl/framebuffer.hpp>
#include <mbgl/gl/vertex_array.hpp>
#include <mbgl/gl/types.hpp>
@@ -60,23 +59,14 @@ public:
#endif
optional<std::pair<BinaryProgramFormat, std::string>> getBinaryProgram(ProgramID) const;
template <gfx::RenderbufferPixelType type>
Renderbuffer<type> createRenderbuffer(const Size size) {
static_assert(type == gfx::RenderbufferPixelType::RGBA ||
type == gfx::RenderbufferPixelType::DepthStencil ||
type == gfx::RenderbufferPixelType::Depth,
"invalid renderbuffer type");
return { size, createRenderbuffer(type, size) };
}
Framebuffer createFramebuffer(const Renderbuffer<gfx::RenderbufferPixelType::RGBA>&,
const Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>&);
Framebuffer createFramebuffer(const Renderbuffer<gfx::RenderbufferPixelType::RGBA>&);
Framebuffer createFramebuffer(const gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA>&,
const gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>&);
Framebuffer createFramebuffer(const gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA>&);
Framebuffer createFramebuffer(const gfx::Texture&,
const Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>&);
const gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil>&);
Framebuffer createFramebuffer(const gfx::Texture&);
Framebuffer createFramebuffer(const gfx::Texture&,
const Renderbuffer<gfx::RenderbufferPixelType::Depth>&);
const gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>&);
template <typename Image,
gfx::TexturePixelType format = Image::channels == 4 ? gfx::TexturePixelType::RGBA
@@ -213,10 +203,11 @@ private:
void updateTextureResource(const gfx::TextureResource&, Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override;
void updateTextureResourceSub(const gfx::TextureResource&, const uint16_t xOffset, const uint16_t yOffset, Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override;
std::unique_ptr<gfx::RenderbufferResource> createRenderbufferResource(gfx::RenderbufferPixelType, Size size) override;
std::unique_ptr<gfx::DrawScopeResource> createDrawScopeResource() override;
UniqueFramebuffer createFramebuffer();
UniqueRenderbuffer createRenderbuffer(gfx::RenderbufferPixelType, Size size);
std::unique_ptr<uint8_t[]> readFramebuffer(Size, gfx::TexturePixelType, bool flip);
#if not MBGL_USE_GLES2
void drawPixels(Size size, const void* data, gfx::TexturePixelType);

33
src/mbgl/gl/renderbuffer.hpp
View File

@@ -1,33 +0,0 @@
#pragma once
#include <mbgl/gfx/types.hpp>
#include <mbgl/gl/object.hpp>
#include <mbgl/util/size.hpp>
namespace mbgl {
namespace gl {
template <gfx::RenderbufferPixelType renderbufferType>
class Renderbuffer {
public:
Renderbuffer(Size size_, UniqueRenderbuffer renderbuffer_, bool dirty_ = false)
: size(std::move(size_)), renderbuffer(std::move(renderbuffer_)), dirty(dirty_) {
}
using type = std::integral_constant<gfx::RenderbufferPixelType, renderbufferType>;
Size size;
UniqueRenderbuffer renderbuffer;
void shouldClear(bool clear) {
dirty = clear;
}
bool needsClearing() {
return dirty;
}
private:
bool dirty;
};
} // namespace gl
} // namespace mbgl

19
src/mbgl/gl/renderbuffer_resource.hpp Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
#include <mbgl/gfx/renderbuffer.hpp>
#include <mbgl/gl/object.hpp>
namespace mbgl {
namespace gl {
class RenderbufferResource final : public gfx::RenderbufferResource {
public:
explicit RenderbufferResource(UniqueRenderbuffer renderbuffer_)
: renderbuffer(std::move(renderbuffer_)) {
}
UniqueRenderbuffer renderbuffer;
};
} // namespace gl
} // namespace mbgl

2
src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
View File

@@ -70,7 +70,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
optional<float> depthClearValue = {};
if (parameters.staticData.depthRenderbuffer->needsClearing()) depthClearValue = 1.0;
// Flag the depth buffer as no longer needing to be cleared for the remainder of this pass.
parameters.staticData.depthRenderbuffer->shouldClear(false);
parameters.staticData.depthRenderbuffer->setShouldClear(false);
glContext.setStencilMode(gfx::StencilMode::disabled());
glContext.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, depthClearValue, {});

4
src/mbgl/renderer/render_static_data.hpp
View File

@@ -2,7 +2,7 @@
#include <mbgl/gfx/vertex_buffer.hpp>
#include <mbgl/gfx/index_buffer.hpp>
#include <mbgl/gl/renderbuffer.hpp>
#include <mbgl/gfx/renderbuffer.hpp>
#include <mbgl/programs/background_program.hpp>
#include <mbgl/programs/extrusion_texture_program.hpp>
#include <mbgl/programs/programs.hpp>
@@ -32,7 +32,7 @@ public:
SegmentVector<RasterAttributes> rasterSegments;
SegmentVector<ExtrusionTextureAttributes> extrusionTextureSegments;
optional<gl::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer;
optional<gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer;
bool has3D = false;
Size backendSize;

6
src/mbgl/renderer/renderer_impl.cpp
View File

@@ -398,11 +398,11 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
parameters.pass = RenderPass::Pass3D;
if (!parameters.staticData.depthRenderbuffer ||
parameters.staticData.depthRenderbuffer->size != parameters.staticData.backendSize) {
parameters.staticData.depthRenderbuffer->getSize() != parameters.staticData.backendSize) {
parameters.staticData.depthRenderbuffer =
glContext.createRenderbuffer<gfx::RenderbufferPixelType::Depth>(parameters.staticData.backendSize);
parameters.context.createRenderbuffer<gfx::RenderbufferPixelType::Depth>(parameters.staticData.backendSize);
}
parameters.staticData.depthRenderbuffer->shouldClear(true);
parameters.staticData.depthRenderbuffer->setShouldClear(true);
uint32_t i = static_cast<uint32_t>(renderItems.size()) - 1;
for (auto it = renderItems.begin(); it != renderItems.end(); ++it, --i) {

6
src/mbgl/util/offscreen_texture.cpp
View File

@@ -17,7 +17,7 @@ public:
}
Impl(gl::Context& context_,
const Size size_,
gl::Renderbuffer<gfx::RenderbufferPixelType::Depth>& depth_,
gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>& depth_,
const gfx::TextureChannelDataType type_)
: context(context_), size(std::move(size_)), depth(&depth_), type(type_) {
assert(!size.isEmpty());
@@ -58,7 +58,7 @@ private:
const Size size;
optional<gl::Framebuffer> framebuffer;
optional<gfx::Texture> texture;
gl::Renderbuffer<gfx::RenderbufferPixelType::Depth>* depth = nullptr;
gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>* depth = nullptr;
const gfx::TextureChannelDataType type;
};
@@ -72,7 +72,7 @@ OffscreenTexture::OffscreenTexture(gfx::Context& context,
OffscreenTexture::OffscreenTexture(gfx::Context& context,
const Size size,
gl::Renderbuffer<gfx::RenderbufferPixelType::Depth>& renderbuffer,
gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>& renderbuffer,
const gfx::TextureChannelDataType type)
// TODO: remove cast
: impl(std::make_unique<Impl>(reinterpret_cast<gl::Context&>(context), std::move(size), renderbuffer, type)) {

5
src/mbgl/util/offscreen_texture.hpp
View File

@@ -1,7 +1,6 @@
#pragma once
#include <mbgl/gl/types.hpp>
#include <mbgl/gl/renderbuffer.hpp>
#include <mbgl/gfx/renderbuffer.hpp>
#include <mbgl/util/image.hpp>
namespace mbgl {
@@ -18,7 +17,7 @@ public:
gfx::TextureChannelDataType type = gfx::TextureChannelDataType::UnsignedByte);
OffscreenTexture(gfx::Context&,
Size size,
gl::Renderbuffer<gfx::RenderbufferPixelType::Depth>&,
gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>&,
gfx::TextureChannelDataType type = gfx::TextureChannelDataType::UnsignedByte);
~OffscreenTexture();
OffscreenTexture(OffscreenTexture&&);