137 lines
6.0 KiB
C++
137 lines
6.0 KiB
C++
#pragma once
|
|
|
|
#include <mln/gfx/context.hpp>
|
|
#include <mln/gfx/vertex_buffer.hpp>
|
|
#include <mln/webgpu/renderer_backend.hpp>
|
|
#include <mln/webgpu/buffer_resource.hpp>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <vector>
|
|
|
|
namespace mln {
|
|
class RenderStaticData;
|
|
namespace gfx {
|
|
// Forward declaration
|
|
class AttributeBinding;
|
|
using AttributeBindingArray = std::vector<std::optional<AttributeBinding>>;
|
|
class RenderPass;
|
|
class Renderable;
|
|
class ShaderProgramBase;
|
|
} // namespace gfx
|
|
|
|
namespace shaders {
|
|
struct ClipUBO;
|
|
} // namespace shaders
|
|
|
|
namespace webgpu {
|
|
|
|
// Forward declaration
|
|
class VertexBufferResource;
|
|
|
|
class Context : public gfx::Context {
|
|
public:
|
|
explicit Context(RendererBackend& backend);
|
|
~Context() override;
|
|
|
|
RendererBackend& getBackend() { return backend; }
|
|
const RendererBackend& getBackend() const { return backend; }
|
|
|
|
// Frame management
|
|
void beginFrame() override;
|
|
void endFrame() override;
|
|
void performCleanup() override;
|
|
void reduceMemoryUsage() override;
|
|
|
|
// Resource creation
|
|
std::unique_ptr<gfx::OffscreenTexture> createOffscreenTexture(Size,
|
|
gfx::TextureChannelDataType,
|
|
bool,
|
|
bool) override;
|
|
std::unique_ptr<gfx::OffscreenTexture> createOffscreenTexture(Size, gfx::TextureChannelDataType) override;
|
|
std::unique_ptr<gfx::CommandEncoder> createCommandEncoder() override;
|
|
gfx::VertexAttributeArrayPtr createVertexAttributeArray() const override;
|
|
gfx::UniqueDrawableBuilder createDrawableBuilder(std::string name) override;
|
|
gfx::UniformBufferPtr createUniformBuffer(const void* data,
|
|
std::size_t size,
|
|
bool persistent = false,
|
|
bool ssbo = false) override;
|
|
gfx::UniqueUniformBufferArray createLayerUniformBufferArray() override;
|
|
gfx::ShaderProgramBasePtr getGenericShader(gfx::ShaderRegistry&, const std::string& name) override;
|
|
TileLayerGroupPtr createTileLayerGroup(int32_t layerIndex, std::size_t initialCapacity, std::string name) override;
|
|
LayerGroupPtr createLayerGroup(int32_t layerIndex, std::size_t initialCapacity, std::string name) override;
|
|
gfx::Texture2DPtr createTexture2D() override;
|
|
gfx::DynamicTexturePtr createDynamicTexture(Size size, gfx::TexturePixelType pixelType) override;
|
|
RenderTargetPtr createRenderTarget(const Size size, const gfx::TextureChannelDataType type) override;
|
|
|
|
// State management
|
|
void resetState(gfx::DepthMode depthMode, gfx::ColorMode colorMode) override;
|
|
void setDirtyState() override;
|
|
void clearStencilBuffer(int32_t) override;
|
|
|
|
// Uniform buffer management
|
|
bool emplaceOrUpdateUniformBuffer(gfx::UniformBufferPtr&,
|
|
const void* data,
|
|
std::size_t size,
|
|
bool persistent = false) override;
|
|
const gfx::UniformBufferArray& getGlobalUniformBuffers() const override;
|
|
gfx::UniformBufferArray& mutableGlobalUniformBuffers() override;
|
|
void bindGlobalUniformBuffers(gfx::RenderPass&) const noexcept override;
|
|
void unbindGlobalUniformBuffers(gfx::RenderPass&) const noexcept override;
|
|
|
|
#if !defined(NDEBUG)
|
|
void visualizeStencilBuffer() override;
|
|
void visualizeDepthBuffer(float depthRangeSize) override;
|
|
#endif
|
|
|
|
// Buffer creation (aligned with Metal)
|
|
BufferResource createBuffer(
|
|
const void* data, std::size_t size, uint32_t usage, bool isIndexBuffer, bool persistent) const;
|
|
|
|
// Get reusable buffers (aligned with Metal)
|
|
const BufferResource& getTileVertexBuffer();
|
|
const BufferResource& getTileIndexBuffer();
|
|
|
|
// Tile clipping mask rendering
|
|
bool renderTileClippingMasks(gfx::RenderPass& renderPass,
|
|
RenderStaticData& staticData,
|
|
const std::vector<shaders::ClipUBO>& tileUBOs);
|
|
|
|
// Command encoder tracking
|
|
class CommandEncoder* getCurrentCommandEncoder() const { return currentCommandEncoder; }
|
|
void setCurrentCommandEncoder(class CommandEncoder* encoder) { currentCommandEncoder = encoder; }
|
|
|
|
// Vertex binding creation - needed for drawable geometry
|
|
gfx::AttributeBindingArray getOrCreateVertexBindings(gfx::Context&,
|
|
const gfx::AttributeDataType vertexType,
|
|
const size_t vertexAttributeIndex,
|
|
const std::vector<uint8_t>& vertexData,
|
|
const gfx::VertexAttributeArray& defaults,
|
|
const gfx::VertexAttributeArray& overrides,
|
|
gfx::BufferUsageType,
|
|
const std::optional<std::chrono::duration<double>>&,
|
|
std::shared_ptr<webgpu::VertexBufferResource>&) noexcept;
|
|
|
|
protected:
|
|
std::unique_ptr<gfx::RenderbufferResource> createRenderbufferResource(gfx::RenderbufferPixelType, Size) override;
|
|
std::unique_ptr<gfx::DrawScopeResource> createDrawScopeResource() override;
|
|
|
|
private:
|
|
RendererBackend& backend;
|
|
std::unique_ptr<gfx::UniformBufferArray> globalUniformBuffers;
|
|
class CommandEncoder* currentCommandEncoder = nullptr;
|
|
|
|
// Cached buffers (aligned with Metal)
|
|
std::optional<BufferResource> tileVertexBuffer;
|
|
std::optional<BufferResource> tileIndexBuffer;
|
|
|
|
// Cached clipping resources
|
|
gfx::ShaderProgramBasePtr clipMaskShader;
|
|
const gfx::Renderable* clipMaskRenderable = nullptr;
|
|
std::optional<std::size_t> clipMaskPipelineHash;
|
|
std::vector<BufferResource> clipMaskUniformBuffers;
|
|
std::vector<WGPUBindGroup> clipMaskActiveBindGroups;
|
|
};
|
|
|
|
} // namespace webgpu
|
|
} // namespace mln
|