diff --git a/src/backend/opengl/BlendStateGL.cpp b/src/backend/opengl/BlendStateGL.cpp index f4aa28503c..d1ead39f25 100644 --- a/src/backend/opengl/BlendStateGL.cpp +++ b/src/backend/opengl/BlendStateGL.cpp @@ -17,8 +17,7 @@ #include "backend/opengl/OpenGLBackend.h" #include "common/Assert.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { GLenum GLBlendFactor(nxt::BlendFactor factor, bool alpha) { @@ -70,7 +69,7 @@ namespace opengl { UNREACHABLE(); } } - } + } // namespace BlendState::BlendState(BlendStateBuilder* builder) : BlendStateBase(builder) { } @@ -80,17 +79,19 @@ namespace opengl { if (info.blendEnabled) { glEnablei(GL_BLEND, attachment); - glBlendEquationSeparatei(attachment, GLBlendMode(info.colorBlend.operation), GLBlendMode(info.alphaBlend.operation)); - glBlendFuncSeparatei(attachment, GLBlendFactor(info.colorBlend.srcFactor, false), GLBlendFactor(info.colorBlend.dstFactor, false), GLBlendFactor(info.alphaBlend.srcFactor, true), GLBlendFactor(info.alphaBlend.dstFactor, true)); - glColorMaski(attachment, - info.colorWriteMask & nxt::ColorWriteMask::Red, - info.colorWriteMask & nxt::ColorWriteMask::Green, - info.colorWriteMask & nxt::ColorWriteMask::Blue, - info.colorWriteMask & nxt::ColorWriteMask::Alpha); + glBlendEquationSeparatei(attachment, GLBlendMode(info.colorBlend.operation), + GLBlendMode(info.alphaBlend.operation)); + glBlendFuncSeparatei(attachment, GLBlendFactor(info.colorBlend.srcFactor, false), + GLBlendFactor(info.colorBlend.dstFactor, false), + GLBlendFactor(info.alphaBlend.srcFactor, true), + GLBlendFactor(info.alphaBlend.dstFactor, true)); + glColorMaski(attachment, info.colorWriteMask & nxt::ColorWriteMask::Red, + info.colorWriteMask & nxt::ColorWriteMask::Green, + info.colorWriteMask & nxt::ColorWriteMask::Blue, + info.colorWriteMask & nxt::ColorWriteMask::Alpha); } else { glDisablei(GL_BLEND, attachment); } } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/BlendStateGL.h b/src/backend/opengl/BlendStateGL.h index e286cd592c..499692d05e 100644 --- a/src/backend/opengl/BlendStateGL.h +++ b/src/backend/opengl/BlendStateGL.h @@ -19,17 +19,15 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class BlendState : public BlendStateBase { - public: - BlendState(BlendStateBuilder* builder); + public: + BlendState(BlendStateBuilder* builder); - void ApplyNow(uint32_t attachment); + void ApplyNow(uint32_t attachment); }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_BLENDSTATED3D12_H_ +#endif // BACKEND_OPENGL_BLENDSTATED3D12_H_ diff --git a/src/backend/opengl/BufferGL.cpp b/src/backend/opengl/BufferGL.cpp index 0086dba4ba..0e82fe350d 100644 --- a/src/backend/opengl/BufferGL.cpp +++ b/src/backend/opengl/BufferGL.cpp @@ -16,13 +16,11 @@ #include "backend/opengl/OpenGLBackend.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { // Buffer - Buffer::Buffer(BufferBuilder* builder) - : BufferBase(builder) { + Buffer::Buffer(BufferBuilder* builder) : BufferBase(builder) { glGenBuffers(1, &mBuffer); glBindBuffer(GL_ARRAY_BUFFER, mBuffer); glBufferData(GL_ARRAY_BUFFER, GetSize(), nullptr, GL_STATIC_DRAW); @@ -40,7 +38,8 @@ namespace opengl { void Buffer::MapReadAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) { // TODO(cwallez@chromium.org): this does GPU->CPU synchronization, we could require a high // version of OpenGL that would let us map the buffer unsynchronized. - // TODO(cwallez@chromium.org): this crashes on Mac NVIDIA, use GetBufferSubData there instead? + // TODO(cwallez@chromium.org): this crashes on Mac NVIDIA, use GetBufferSubData there + // instead? glBindBuffer(GL_ARRAY_BUFFER, mBuffer); void* data = glMapBufferRange(GL_ARRAY_BUFFER, start, count, GL_MAP_READ_BIT); CallMapReadCallback(serial, NXT_BUFFER_MAP_READ_STATUS_SUCCESS, data); @@ -56,9 +55,7 @@ namespace opengl { // BufferView - BufferView::BufferView(BufferViewBuilder* builder) - : BufferViewBase(builder) { + BufferView::BufferView(BufferViewBuilder* builder) : BufferViewBase(builder) { } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/BufferGL.h b/src/backend/opengl/BufferGL.h index fb589c7a77..4dfa96a96a 100644 --- a/src/backend/opengl/BufferGL.h +++ b/src/backend/opengl/BufferGL.h @@ -19,32 +19,31 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class Buffer : public BufferBase { - public: - Buffer(BufferBuilder* builder); + public: + Buffer(BufferBuilder* builder); - GLuint GetHandle() const; + GLuint GetHandle() const; - private: - void SetSubDataImpl(uint32_t start, uint32_t count, const uint32_t* data) override; - void MapReadAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) override; - void UnmapImpl() override; - void TransitionUsageImpl(nxt::BufferUsageBit currentUsage, nxt::BufferUsageBit targetUsage) override; + private: + void SetSubDataImpl(uint32_t start, uint32_t count, const uint32_t* data) override; + void MapReadAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) override; + void UnmapImpl() override; + void TransitionUsageImpl(nxt::BufferUsageBit currentUsage, + nxt::BufferUsageBit targetUsage) override; - GLuint mBuffer = 0; + GLuint mBuffer = 0; }; class BufferView : public BufferViewBase { - public: - BufferView(BufferViewBuilder* builder); + public: + BufferView(BufferViewBuilder* builder); }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_BUFFERGL_H_ +#endif // BACKEND_OPENGL_BUFFERGL_H_ diff --git a/src/backend/opengl/CommandBufferGL.cpp b/src/backend/opengl/CommandBufferGL.cpp index 32eead8024..c8be720cfc 100644 --- a/src/backend/opengl/CommandBufferGL.cpp +++ b/src/backend/opengl/CommandBufferGL.cpp @@ -27,8 +27,7 @@ #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { @@ -55,148 +54,159 @@ namespace opengl { } } - // Push constants are implemented using OpenGL uniforms, however they aren't part of the global - // OpenGL state but are part of the program state instead. This means that we have to reapply - // push constants on pipeline change. + // Push constants are implemented using OpenGL uniforms, however they aren't part of the + // global OpenGL state but are part of the program state instead. This means that we have to + // reapply push constants on pipeline change. // - // This structure tracks the current values of push constants as well as dirty bits for push constants - // that should be applied before the next draw or dispatch. + // This structure tracks the current values of push constants as well as dirty bits for push + // constants that should be applied before the next draw or dispatch. class PushConstantTracker { - public: - void OnBeginPass() { - for (auto stage : IterateStages(kAllStages)) { - mValues[stage].fill(0); - // No need to set dirty bits as a pipeline will be set before the next operation - // using push constants. - } + public: + void OnBeginPass() { + for (auto stage : IterateStages(kAllStages)) { + mValues[stage].fill(0); + // No need to set dirty bits as a pipeline will be set before the next operation + // using push constants. } + } - void OnSetPushConstants(nxt::ShaderStageBit stages, uint32_t count, - uint32_t offset, const uint32_t* data) { - for (auto stage : IterateStages(stages)) { - memcpy(&mValues[stage][offset], data, count * sizeof(uint32_t)); + void OnSetPushConstants(nxt::ShaderStageBit stages, + uint32_t count, + uint32_t offset, + const uint32_t* data) { + for (auto stage : IterateStages(stages)) { + memcpy(&mValues[stage][offset], data, count * sizeof(uint32_t)); - // Use 64 bit masks and make sure there are no shift UB - static_assert(kMaxPushConstants <= 8 * sizeof(unsigned long long) - 1, ""); - mDirtyBits[stage] |= ((1ull << count) - 1ull) << offset; - } + // Use 64 bit masks and make sure there are no shift UB + static_assert(kMaxPushConstants <= 8 * sizeof(unsigned long long) - 1, ""); + mDirtyBits[stage] |= ((1ull << count) - 1ull) << offset; } + } - void OnSetPipeline(PipelineBase* pipeline) { - for (auto stage : IterateStages(kAllStages)) { - mDirtyBits[stage] = pipeline->GetPushConstants(stage).mask; - } + void OnSetPipeline(PipelineBase* pipeline) { + for (auto stage : IterateStages(kAllStages)) { + mDirtyBits[stage] = pipeline->GetPushConstants(stage).mask; } + } - void Apply(PipelineBase* pipeline, PipelineGL* glPipeline) { - for (auto stage : IterateStages(kAllStages)) { - const auto& pushConstants = pipeline->GetPushConstants(stage); - const auto& glPushConstants = glPipeline->GetGLPushConstants(stage); + void Apply(PipelineBase* pipeline, PipelineGL* glPipeline) { + for (auto stage : IterateStages(kAllStages)) { + const auto& pushConstants = pipeline->GetPushConstants(stage); + const auto& glPushConstants = glPipeline->GetGLPushConstants(stage); - for (uint32_t constant : IterateBitSet(mDirtyBits[stage] & pushConstants.mask)) { - GLint location = glPushConstants[constant]; - switch (pushConstants.types[constant]) { - case PushConstantType::Int: - glUniform1i(location, *reinterpret_cast(&mValues[stage][constant])); - break; - case PushConstantType::UInt: - glUniform1ui(location, *reinterpret_cast(&mValues[stage][constant])); - break; - case PushConstantType::Float: - glUniform1f(location, *reinterpret_cast(&mValues[stage][constant])); - break; - } + for (uint32_t constant : + IterateBitSet(mDirtyBits[stage] & pushConstants.mask)) { + GLint location = glPushConstants[constant]; + switch (pushConstants.types[constant]) { + case PushConstantType::Int: + glUniform1i(location, + *reinterpret_cast(&mValues[stage][constant])); + break; + case PushConstantType::UInt: + glUniform1ui(location, + *reinterpret_cast(&mValues[stage][constant])); + break; + case PushConstantType::Float: + glUniform1f(location, + *reinterpret_cast(&mValues[stage][constant])); + break; } - - mDirtyBits[stage].reset(); } - } - private: + mDirtyBits[stage].reset(); + } + } + + private: PerStage> mValues; PerStage> mDirtyBits; }; - // Vertex buffers and index buffers are implemented as part of an OpenGL VAO that corresponds to an - // InputState. On the contrary in NXT they are part of the global state. This means that we have to - // re-apply these buffers on an InputState change. + // Vertex buffers and index buffers are implemented as part of an OpenGL VAO that + // corresponds to an InputState. On the contrary in NXT they are part of the global state. + // This means that we have to re-apply these buffers on an InputState change. class InputBufferTracker { - public: - void OnBeginPass() { - // We don't know what happened between this pass and the last one, just reset the - // input state so everything gets reapplied. - mLastInputState = nullptr; + public: + void OnBeginPass() { + // We don't know what happened between this pass and the last one, just reset the + // input state so everything gets reapplied. + mLastInputState = nullptr; + } + + void OnSetIndexBuffer(BufferBase* buffer) { + mIndexBufferDirty = true; + mIndexBuffer = ToBackend(buffer); + } + + void OnSetVertexBuffers(uint32_t startSlot, + uint32_t count, + Ref* buffers, + uint32_t* offsets) { + for (uint32_t i = 0; i < count; ++i) { + uint32_t slot = startSlot + i; + mVertexBuffers[slot] = ToBackend(buffers[i].Get()); + mVertexBufferOffsets[slot] = offsets[i]; } - void OnSetIndexBuffer(BufferBase* buffer) { - mIndexBufferDirty = true; - mIndexBuffer = ToBackend(buffer); + // Use 64 bit masks and make sure there are no shift UB + static_assert(kMaxVertexInputs <= 8 * sizeof(unsigned long long) - 1, ""); + mDirtyVertexBuffers |= ((1ull << count) - 1ull) << startSlot; + } + + void OnSetPipeline(RenderPipelineBase* pipeline) { + InputStateBase* inputState = pipeline->GetInputState(); + if (mLastInputState == inputState) { + return; } - void OnSetVertexBuffers(uint32_t startSlot, uint32_t count, Ref* buffers, uint32_t* offsets) { - for (uint32_t i = 0; i < count; ++i) { - uint32_t slot = startSlot + i; - mVertexBuffers[slot] = ToBackend(buffers[i].Get()); - mVertexBufferOffsets[slot] = offsets[i]; + mIndexBufferDirty = true; + mDirtyVertexBuffers |= inputState->GetInputsSetMask(); + + mLastInputState = ToBackend(inputState); + } + + void Apply() { + if (mIndexBufferDirty && mIndexBuffer != nullptr) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer->GetHandle()); + mIndexBufferDirty = false; + } + + for (uint32_t slot : + IterateBitSet(mDirtyVertexBuffers & mLastInputState->GetInputsSetMask())) { + for (uint32_t location : + IterateBitSet(mLastInputState->GetAttributesUsingInput(slot))) { + auto attribute = mLastInputState->GetAttribute(location); + + GLuint buffer = mVertexBuffers[slot]->GetHandle(); + uint32_t offset = mVertexBufferOffsets[slot]; + + auto input = mLastInputState->GetInput(slot); + auto components = VertexFormatNumComponents(attribute.format); + auto formatType = VertexFormatType(attribute.format); + + glBindBuffer(GL_ARRAY_BUFFER, buffer); + glVertexAttribPointer( + location, components, formatType, GL_FALSE, input.stride, + reinterpret_cast( + static_cast(offset + attribute.offset))); } - - // Use 64 bit masks and make sure there are no shift UB - static_assert(kMaxVertexInputs <= 8 * sizeof(unsigned long long) - 1, ""); - mDirtyVertexBuffers |= ((1ull << count) - 1ull) << startSlot; } - void OnSetPipeline(RenderPipelineBase* pipeline) { - InputStateBase* inputState = pipeline->GetInputState(); - if (mLastInputState == inputState) { - return; - } + mDirtyVertexBuffers.reset(); + } - mIndexBufferDirty = true; - mDirtyVertexBuffers |= inputState->GetInputsSetMask(); + private: + bool mIndexBufferDirty = false; + Buffer* mIndexBuffer = nullptr; - mLastInputState = ToBackend(inputState); - } + std::bitset mDirtyVertexBuffers; + std::array mVertexBuffers; + std::array mVertexBufferOffsets; - void Apply() { - if (mIndexBufferDirty && mIndexBuffer != nullptr) { - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer->GetHandle()); - mIndexBufferDirty = false; - } - - for (uint32_t slot : IterateBitSet(mDirtyVertexBuffers & mLastInputState->GetInputsSetMask())) { - for (uint32_t location : IterateBitSet(mLastInputState->GetAttributesUsingInput(slot))) { - auto attribute = mLastInputState->GetAttribute(location); - - GLuint buffer = mVertexBuffers[slot]->GetHandle(); - uint32_t offset = mVertexBufferOffsets[slot]; - - auto input = mLastInputState->GetInput(slot); - auto components = VertexFormatNumComponents(attribute.format); - auto formatType = VertexFormatType(attribute.format); - - glBindBuffer(GL_ARRAY_BUFFER, buffer); - glVertexAttribPointer( - location, components, formatType, GL_FALSE, - input.stride, - reinterpret_cast(static_cast(offset + attribute.offset))); - } - } - - mDirtyVertexBuffers.reset(); - } - - private: - bool mIndexBufferDirty = false; - Buffer* mIndexBuffer = nullptr; - - std::bitset mDirtyVertexBuffers; - std::array mVertexBuffers; - std::array mVertexBufferOffsets; - - InputState* mLastInputState = nullptr; + InputState* mLastInputState = nullptr; }; - } + } // namespace CommandBuffer::CommandBuffer(CommandBufferBuilder* builder) : CommandBufferBase(builder), mCommands(builder->AcquireCommands()) { @@ -224,426 +234,402 @@ namespace opengl { uint32_t currentSubpass = 0; GLuint currentFBO = 0; - while(mCommands.NextCommandId(&type)) { + while (mCommands.NextCommandId(&type)) { switch (type) { - case Command::BeginComputePass: - { - mCommands.NextCommand(); - pushConstants.OnBeginPass(); + case Command::BeginComputePass: { + mCommands.NextCommand(); + pushConstants.OnBeginPass(); + } break; + + case Command::BeginRenderPass: { + auto* cmd = mCommands.NextCommand(); + currentRenderPass = ToBackend(cmd->renderPass.Get()); + currentFramebuffer = ToBackend(cmd->framebuffer.Get()); + currentSubpass = 0; + } break; + + case Command::BeginRenderSubpass: { + mCommands.NextCommand(); + pushConstants.OnBeginPass(); + inputBuffers.OnBeginPass(); + + // TODO(kainino@chromium.org): This is added to possibly + // work around an issue seen on Windows/Intel. It should + // break any feedback loop before the clears, even if + // there shouldn't be any negative effects from this. + // Investigate whether it's actually needed. + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + // TODO(kainino@chromium.org): possible future + // optimization: create these framebuffers at + // Framebuffer build time (or maybe CommandBuffer build + // time) so they don't have to be created and destroyed + // at draw time. + glGenFramebuffers(1, ¤tFBO); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, currentFBO); + + const auto& subpass = currentRenderPass->GetSubpassInfo(currentSubpass); + + // Mapping from attachmentSlot to GL framebuffer + // attachment points. Defaults to zero (GL_NONE). + std::array drawBuffers = {}; + + // Construct GL framebuffer + + unsigned int attachmentCount = 0; + for (unsigned int location : IterateBitSet(subpass.colorAttachmentsSet)) { + uint32_t attachment = subpass.colorAttachments[location]; + + auto textureView = currentFramebuffer->GetTextureView(attachment); + GLuint texture = ToBackend(textureView->GetTexture())->GetHandle(); + + // Attach color buffers. + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + location, + GL_TEXTURE_2D, texture, 0); + drawBuffers[location] = GL_COLOR_ATTACHMENT0 + location; + attachmentCount = location + 1; + + // TODO(kainino@chromium.org): the color clears (later in + // this function) may be undefined for other texture formats. + ASSERT(textureView->GetTexture()->GetFormat() == + nxt::TextureFormat::R8G8B8A8Unorm); } - break; + glDrawBuffers(attachmentCount, drawBuffers.data()); - case Command::BeginRenderPass: - { - auto* cmd = mCommands.NextCommand(); - currentRenderPass = ToBackend(cmd->renderPass.Get()); - currentFramebuffer = ToBackend(cmd->framebuffer.Get()); - currentSubpass = 0; - } - break; + if (subpass.depthStencilAttachmentSet) { + uint32_t attachmentSlot = subpass.depthStencilAttachment; - case Command::BeginRenderSubpass: - { - mCommands.NextCommand(); - pushConstants.OnBeginPass(); - inputBuffers.OnBeginPass(); + auto textureView = currentFramebuffer->GetTextureView(attachmentSlot); + GLuint texture = ToBackend(textureView->GetTexture())->GetHandle(); + nxt::TextureFormat format = textureView->GetTexture()->GetFormat(); - // TODO(kainino@chromium.org): This is added to possibly - // work around an issue seen on Windows/Intel. It should - // break any feedback loop before the clears, even if - // there shouldn't be any negative effects from this. - // Investigate whether it's actually needed. - glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); - // TODO(kainino@chromium.org): possible future - // optimization: create these framebuffers at - // Framebuffer build time (or maybe CommandBuffer build - // time) so they don't have to be created and destroyed - // at draw time. - glGenFramebuffers(1, ¤tFBO); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, currentFBO); - - const auto& subpass = currentRenderPass->GetSubpassInfo(currentSubpass); - - // Mapping from attachmentSlot to GL framebuffer - // attachment points. Defaults to zero (GL_NONE). - std::array drawBuffers = {}; - - // Construct GL framebuffer - - unsigned int attachmentCount = 0; - for (unsigned int location : IterateBitSet(subpass.colorAttachmentsSet)) { - uint32_t attachment = subpass.colorAttachments[location]; - - auto textureView = currentFramebuffer->GetTextureView(attachment); - GLuint texture = ToBackend(textureView->GetTexture())->GetHandle(); - - // Attach color buffers. - glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, - GL_COLOR_ATTACHMENT0 + location, - GL_TEXTURE_2D, texture, 0); - drawBuffers[location] = GL_COLOR_ATTACHMENT0 + location; - attachmentCount = location + 1; - - // TODO(kainino@chromium.org): the color clears (later in - // this function) may be undefined for other texture formats. - ASSERT(textureView->GetTexture()->GetFormat() == nxt::TextureFormat::R8G8B8A8Unorm); - } - glDrawBuffers(attachmentCount, drawBuffers.data()); - - if (subpass.depthStencilAttachmentSet) { - uint32_t attachmentSlot = subpass.depthStencilAttachment; - - auto textureView = currentFramebuffer->GetTextureView(attachmentSlot); - GLuint texture = ToBackend(textureView->GetTexture())->GetHandle(); - nxt::TextureFormat format = textureView->GetTexture()->GetFormat(); - - // Attach depth/stencil buffer. - GLenum glAttachment = 0; - // TODO(kainino@chromium.org): it may be valid to just always use GL_DEPTH_STENCIL_ATTACHMENT here. - if (TextureFormatHasDepth(format)) { - if (TextureFormatHasStencil(format)) { - glAttachment = GL_DEPTH_STENCIL_ATTACHMENT; - } else { - glAttachment = GL_DEPTH_ATTACHMENT; - } + // Attach depth/stencil buffer. + GLenum glAttachment = 0; + // TODO(kainino@chromium.org): it may be valid to just always use + // GL_DEPTH_STENCIL_ATTACHMENT here. + if (TextureFormatHasDepth(format)) { + if (TextureFormatHasStencil(format)) { + glAttachment = GL_DEPTH_STENCIL_ATTACHMENT; } else { - glAttachment = GL_STENCIL_ATTACHMENT; + glAttachment = GL_DEPTH_ATTACHMENT; } - - glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, glAttachment, GL_TEXTURE_2D, texture, 0); - - // TODO(kainino@chromium.org): the depth/stencil clears (later in - // this function) may be undefined for other texture formats. - ASSERT(format == nxt::TextureFormat::D32FloatS8Uint); - } - - // Clear framebuffer attachments as needed - - for (unsigned int location : IterateBitSet(subpass.colorAttachmentsSet)) { - uint32_t attachmentSlot = subpass.colorAttachments[location]; - const auto& attachmentInfo = currentRenderPass->GetAttachmentInfo(attachmentSlot); - - // Only perform load op on first use - if (attachmentInfo.firstSubpass == currentSubpass) { - // Load op - color - if (attachmentInfo.colorLoadOp == nxt::LoadOp::Clear) { - const auto& clear = currentFramebuffer->GetClearColor(location); - glClearBufferfv(GL_COLOR, location, clear.color); - } - } - } - - if (subpass.depthStencilAttachmentSet) { - uint32_t attachmentSlot = subpass.depthStencilAttachment; - const auto& attachmentInfo = currentRenderPass->GetAttachmentInfo(attachmentSlot); - - // Only perform load op on first use - if (attachmentInfo.firstSubpass == currentSubpass) { - // Load op - depth/stencil - const auto& clear = currentFramebuffer->GetClearDepthStencil(subpass.depthStencilAttachment); - bool doDepthClear = TextureFormatHasDepth(attachmentInfo.format) && - (attachmentInfo.depthLoadOp == nxt::LoadOp::Clear); - bool doStencilClear = TextureFormatHasStencil(attachmentInfo.format) && - (attachmentInfo.stencilLoadOp == nxt::LoadOp::Clear); - if (doDepthClear && doStencilClear) { - glClearBufferfi(GL_DEPTH_STENCIL, 0, clear.depth, clear.stencil); - } else if (doDepthClear) { - glClearBufferfv(GL_DEPTH, 0, &clear.depth); - } else if (doStencilClear) { - const GLint clearStencil = clear.stencil; - glClearBufferiv(GL_STENCIL, 0, &clearStencil); - } - } - } - - glBlendColor(0, 0, 0, 0); - glViewport(0, 0, currentFramebuffer->GetWidth(), currentFramebuffer->GetHeight()); - } - break; - - case Command::CopyBufferToBuffer: - { - CopyBufferToBufferCmd* copy = mCommands.NextCommand(); - auto& src = copy->source; - auto& dst = copy->destination; - - glBindBuffer(GL_PIXEL_PACK_BUFFER, ToBackend(src.buffer)->GetHandle()); - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, ToBackend(dst.buffer)->GetHandle()); - glCopyBufferSubData(GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, src.offset, dst.offset, copy->size); - - glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); - } - break; - - case Command::CopyBufferToTexture: - { - CopyBufferToTextureCmd* copy = mCommands.NextCommand(); - auto& src = copy->source; - auto& dst = copy->destination; - Buffer* buffer = ToBackend(src.buffer.Get()); - Texture* texture = ToBackend(dst.texture.Get()); - GLenum target = texture->GetGLTarget(); - auto format = texture->GetGLFormat(); - - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->GetHandle()); - glActiveTexture(GL_TEXTURE0); - glBindTexture(target, texture->GetHandle()); - - ASSERT(texture->GetDimension() == nxt::TextureDimension::e2D); - glPixelStorei(GL_UNPACK_ROW_LENGTH, copy->rowPitch / TextureFormatPixelSize(texture->GetFormat())); - glTexSubImage2D(target, dst.level, dst.x, dst.y, dst.width, dst.height, - format.format, format.type, - reinterpret_cast(static_cast(src.offset))); - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); - } - break; - - case Command::CopyTextureToBuffer: - { - CopyTextureToBufferCmd* copy = mCommands.NextCommand(); - auto& src = copy->source; - auto& dst = copy->destination; - Texture* texture = ToBackend(src.texture.Get()); - Buffer* buffer = ToBackend(dst.buffer.Get()); - auto format = texture->GetGLFormat(); - - // The only way to move data from a texture to a buffer in GL is via - // glReadPixels with a pack buffer. Create a temporary FBO for the copy. - ASSERT(texture->GetDimension() == nxt::TextureDimension::e2D); - glBindTexture(GL_TEXTURE_2D, texture->GetHandle()); - - GLuint readFBO = 0; - glGenFramebuffers(1, &readFBO); - glBindFramebuffer(GL_READ_FRAMEBUFFER, readFBO); - - glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, - texture->GetHandle(), src.level); - - glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer->GetHandle()); - glPixelStorei(GL_PACK_ROW_LENGTH, copy->rowPitch / TextureFormatPixelSize(texture->GetFormat())); - ASSERT(src.depth == 1 && src.z == 0); - void* offset = reinterpret_cast(static_cast(dst.offset)); - glReadPixels(src.x, src.y, src.width, src.height, format.format, format.type, offset); - glPixelStorei(GL_PACK_ROW_LENGTH, 0); - - glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); - glDeleteFramebuffers(1, &readFBO); - } - break; - - case Command::Dispatch: - { - DispatchCmd* dispatch = mCommands.NextCommand(); - pushConstants.Apply(lastPipeline, lastGLPipeline); - glDispatchCompute(dispatch->x, dispatch->y, dispatch->z); - // TODO(cwallez@chromium.org): add barriers to the API - glMemoryBarrier(GL_ALL_BARRIER_BITS); - } - break; - - case Command::DrawArrays: - { - DrawArraysCmd* draw = mCommands.NextCommand(); - pushConstants.Apply(lastPipeline, lastGLPipeline); - inputBuffers.Apply(); - - if (draw->firstInstance > 0) { - glDrawArraysInstancedBaseInstance(lastRenderPipeline->GetGLPrimitiveTopology(), - draw->firstVertex, draw->vertexCount, draw->instanceCount, draw->firstInstance); } else { - // This branch is only needed on OpenGL < 4.2 - glDrawArraysInstanced(lastRenderPipeline->GetGLPrimitiveTopology(), - draw->firstVertex, draw->vertexCount, draw->instanceCount); + glAttachment = GL_STENCIL_ATTACHMENT; } + + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, glAttachment, GL_TEXTURE_2D, + texture, 0); + + // TODO(kainino@chromium.org): the depth/stencil clears (later in + // this function) may be undefined for other texture formats. + ASSERT(format == nxt::TextureFormat::D32FloatS8Uint); } - break; - case Command::DrawElements: - { - DrawElementsCmd* draw = mCommands.NextCommand(); - pushConstants.Apply(lastPipeline, lastGLPipeline); - inputBuffers.Apply(); + // Clear framebuffer attachments as needed - nxt::IndexFormat indexFormat = lastRenderPipeline->GetIndexFormat(); - size_t formatSize = IndexFormatSize(indexFormat); - GLenum formatType = IndexFormatType(indexFormat); + for (unsigned int location : IterateBitSet(subpass.colorAttachmentsSet)) { + uint32_t attachmentSlot = subpass.colorAttachments[location]; + const auto& attachmentInfo = + currentRenderPass->GetAttachmentInfo(attachmentSlot); - if (draw->firstInstance > 0) { - glDrawElementsInstancedBaseInstance(lastRenderPipeline->GetGLPrimitiveTopology(), - draw->indexCount, formatType, - reinterpret_cast(draw->firstIndex * formatSize + indexBufferOffset), - draw->instanceCount, draw->firstInstance); - } else { - // This branch is only needed on OpenGL < 4.2 - glDrawElementsInstanced(lastRenderPipeline->GetGLPrimitiveTopology(), - draw->indexCount, formatType, - reinterpret_cast(draw->firstIndex * formatSize + indexBufferOffset), - draw->instanceCount); - } - } - break; - - case Command::EndComputePass: - { - mCommands.NextCommand(); - } - break; - - case Command::EndRenderPass: - { - mCommands.NextCommand(); - } - break; - - case Command::EndRenderSubpass: - { - mCommands.NextCommand(); - glDeleteFramebuffers(1, ¤tFBO); - currentFBO = 0; - currentSubpass += 1; - } - break; - - case Command::SetComputePipeline: - { - SetComputePipelineCmd* cmd = mCommands.NextCommand(); - ToBackend(cmd->pipeline)->ApplyNow(); - lastGLPipeline = ToBackend(cmd->pipeline).Get(); - lastPipeline = ToBackend(cmd->pipeline).Get(); - pushConstants.OnSetPipeline(lastPipeline); - } - break; - - case Command::SetRenderPipeline: - { - SetRenderPipelineCmd* cmd = mCommands.NextCommand(); - ToBackend(cmd->pipeline)->ApplyNow(persistentPipelineState); - lastRenderPipeline = ToBackend(cmd->pipeline).Get(); - lastGLPipeline = ToBackend(cmd->pipeline).Get(); - lastPipeline = ToBackend(cmd->pipeline).Get(); - - pushConstants.OnSetPipeline(lastPipeline); - inputBuffers.OnSetPipeline(lastRenderPipeline); - } - break; - - case Command::SetPushConstants: - { - SetPushConstantsCmd* cmd = mCommands.NextCommand(); - uint32_t* data = mCommands.NextData(cmd->count); - pushConstants.OnSetPushConstants(cmd->stages, cmd->count, cmd->offset, data); - } - break; - - case Command::SetStencilReference: - { - SetStencilReferenceCmd* cmd = mCommands.NextCommand(); - persistentPipelineState.SetStencilReference(cmd->reference); - } - break; - - case Command::SetBlendColor: - { - SetBlendColorCmd* cmd = mCommands.NextCommand(); - glBlendColor(cmd->r, cmd->g, cmd->b, cmd->a); - } - break; - - case Command::SetBindGroup: - { - SetBindGroupCmd* cmd = mCommands.NextCommand(); - size_t groupIndex = cmd->index; - BindGroup* group = ToBackend(cmd->group.Get()); - - const auto& indices = ToBackend(lastPipeline->GetLayout())->GetBindingIndexInfo()[groupIndex]; - const auto& layout = group->GetLayout()->GetBindingInfo(); - - for (uint32_t binding : IterateBitSet(layout.mask)) { - switch (layout.types[binding]) { - case nxt::BindingType::UniformBuffer: - { - BufferView* view = ToBackend(group->GetBindingAsBufferView(binding)); - GLuint buffer = ToBackend(view->GetBuffer())->GetHandle(); - GLuint uboIndex = indices[binding]; - - glBindBufferRange(GL_UNIFORM_BUFFER, uboIndex, buffer, view->GetOffset(), view->GetSize()); - } - break; - - case nxt::BindingType::Sampler: - { - GLuint sampler = ToBackend(group->GetBindingAsSampler(binding))->GetHandle(); - GLuint samplerIndex = indices[binding]; - - for (auto unit : lastGLPipeline->GetTextureUnitsForSampler(samplerIndex)) { - glBindSampler(unit, sampler); - } - } - break; - - case nxt::BindingType::SampledTexture: - { - TextureView* view = ToBackend(group->GetBindingAsTextureView(binding)); - Texture* texture = ToBackend(view->GetTexture()); - GLuint handle = texture->GetHandle(); - GLenum target = texture->GetGLTarget(); - GLuint textureIndex = indices[binding]; - - for (auto unit : lastGLPipeline->GetTextureUnitsForTexture(textureIndex)) { - glActiveTexture(GL_TEXTURE0 + unit); - glBindTexture(target, handle); - } - } - break; - - case nxt::BindingType::StorageBuffer: - { - BufferView* view = ToBackend(group->GetBindingAsBufferView(binding)); - GLuint buffer = ToBackend(view->GetBuffer())->GetHandle(); - GLuint ssboIndex = indices[binding]; - - glBindBufferRange(GL_SHADER_STORAGE_BUFFER, ssboIndex, buffer, view->GetOffset(), view->GetSize()); - } - break; + // Only perform load op on first use + if (attachmentInfo.firstSubpass == currentSubpass) { + // Load op - color + if (attachmentInfo.colorLoadOp == nxt::LoadOp::Clear) { + const auto& clear = currentFramebuffer->GetClearColor(location); + glClearBufferfv(GL_COLOR, location, clear.color); } } } - break; - case Command::SetIndexBuffer: - { - SetIndexBufferCmd* cmd = mCommands.NextCommand(); - indexBufferOffset = cmd->offset; - inputBuffers.OnSetIndexBuffer(cmd->buffer.Get()); + if (subpass.depthStencilAttachmentSet) { + uint32_t attachmentSlot = subpass.depthStencilAttachment; + const auto& attachmentInfo = + currentRenderPass->GetAttachmentInfo(attachmentSlot); + + // Only perform load op on first use + if (attachmentInfo.firstSubpass == currentSubpass) { + // Load op - depth/stencil + const auto& clear = currentFramebuffer->GetClearDepthStencil( + subpass.depthStencilAttachment); + bool doDepthClear = TextureFormatHasDepth(attachmentInfo.format) && + (attachmentInfo.depthLoadOp == nxt::LoadOp::Clear); + bool doStencilClear = + TextureFormatHasStencil(attachmentInfo.format) && + (attachmentInfo.stencilLoadOp == nxt::LoadOp::Clear); + if (doDepthClear && doStencilClear) { + glClearBufferfi(GL_DEPTH_STENCIL, 0, clear.depth, clear.stencil); + } else if (doDepthClear) { + glClearBufferfv(GL_DEPTH, 0, &clear.depth); + } else if (doStencilClear) { + const GLint clearStencil = clear.stencil; + glClearBufferiv(GL_STENCIL, 0, &clearStencil); + } + } } - break; - case Command::SetVertexBuffers: - { - SetVertexBuffersCmd* cmd = mCommands.NextCommand(); - auto buffers = mCommands.NextData>(cmd->count); - auto offsets = mCommands.NextData(cmd->count); - inputBuffers.OnSetVertexBuffers(cmd->startSlot, cmd->count, buffers, offsets); + glBlendColor(0, 0, 0, 0); + glViewport(0, 0, currentFramebuffer->GetWidth(), + currentFramebuffer->GetHeight()); + } break; + + case Command::CopyBufferToBuffer: { + CopyBufferToBufferCmd* copy = mCommands.NextCommand(); + auto& src = copy->source; + auto& dst = copy->destination; + + glBindBuffer(GL_PIXEL_PACK_BUFFER, ToBackend(src.buffer)->GetHandle()); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, ToBackend(dst.buffer)->GetHandle()); + glCopyBufferSubData(GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, src.offset, + dst.offset, copy->size); + + glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + } break; + + case Command::CopyBufferToTexture: { + CopyBufferToTextureCmd* copy = mCommands.NextCommand(); + auto& src = copy->source; + auto& dst = copy->destination; + Buffer* buffer = ToBackend(src.buffer.Get()); + Texture* texture = ToBackend(dst.texture.Get()); + GLenum target = texture->GetGLTarget(); + auto format = texture->GetGLFormat(); + + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->GetHandle()); + glActiveTexture(GL_TEXTURE0); + glBindTexture(target, texture->GetHandle()); + + ASSERT(texture->GetDimension() == nxt::TextureDimension::e2D); + glPixelStorei(GL_UNPACK_ROW_LENGTH, + copy->rowPitch / TextureFormatPixelSize(texture->GetFormat())); + glTexSubImage2D(target, dst.level, dst.x, dst.y, dst.width, dst.height, + format.format, format.type, + reinterpret_cast(static_cast(src.offset))); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + } break; + + case Command::CopyTextureToBuffer: { + CopyTextureToBufferCmd* copy = mCommands.NextCommand(); + auto& src = copy->source; + auto& dst = copy->destination; + Texture* texture = ToBackend(src.texture.Get()); + Buffer* buffer = ToBackend(dst.buffer.Get()); + auto format = texture->GetGLFormat(); + + // The only way to move data from a texture to a buffer in GL is via + // glReadPixels with a pack buffer. Create a temporary FBO for the copy. + ASSERT(texture->GetDimension() == nxt::TextureDimension::e2D); + glBindTexture(GL_TEXTURE_2D, texture->GetHandle()); + + GLuint readFBO = 0; + glGenFramebuffers(1, &readFBO); + glBindFramebuffer(GL_READ_FRAMEBUFFER, readFBO); + + glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, + texture->GetHandle(), src.level); + + glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer->GetHandle()); + glPixelStorei(GL_PACK_ROW_LENGTH, + copy->rowPitch / TextureFormatPixelSize(texture->GetFormat())); + ASSERT(src.depth == 1 && src.z == 0); + void* offset = reinterpret_cast(static_cast(dst.offset)); + glReadPixels(src.x, src.y, src.width, src.height, format.format, format.type, + offset); + glPixelStorei(GL_PACK_ROW_LENGTH, 0); + + glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); + glDeleteFramebuffers(1, &readFBO); + } break; + + case Command::Dispatch: { + DispatchCmd* dispatch = mCommands.NextCommand(); + pushConstants.Apply(lastPipeline, lastGLPipeline); + glDispatchCompute(dispatch->x, dispatch->y, dispatch->z); + // TODO(cwallez@chromium.org): add barriers to the API + glMemoryBarrier(GL_ALL_BARRIER_BITS); + } break; + + case Command::DrawArrays: { + DrawArraysCmd* draw = mCommands.NextCommand(); + pushConstants.Apply(lastPipeline, lastGLPipeline); + inputBuffers.Apply(); + + if (draw->firstInstance > 0) { + glDrawArraysInstancedBaseInstance( + lastRenderPipeline->GetGLPrimitiveTopology(), draw->firstVertex, + draw->vertexCount, draw->instanceCount, draw->firstInstance); + } else { + // This branch is only needed on OpenGL < 4.2 + glDrawArraysInstanced(lastRenderPipeline->GetGLPrimitiveTopology(), + draw->firstVertex, draw->vertexCount, + draw->instanceCount); } - break; + } break; - case Command::TransitionBufferUsage: - { - TransitionBufferUsageCmd* cmd = mCommands.NextCommand(); + case Command::DrawElements: { + DrawElementsCmd* draw = mCommands.NextCommand(); + pushConstants.Apply(lastPipeline, lastGLPipeline); + inputBuffers.Apply(); - cmd->buffer->UpdateUsageInternal(cmd->usage); + nxt::IndexFormat indexFormat = lastRenderPipeline->GetIndexFormat(); + size_t formatSize = IndexFormatSize(indexFormat); + GLenum formatType = IndexFormatType(indexFormat); + + if (draw->firstInstance > 0) { + glDrawElementsInstancedBaseInstance( + lastRenderPipeline->GetGLPrimitiveTopology(), draw->indexCount, + formatType, + reinterpret_cast(draw->firstIndex * formatSize + + indexBufferOffset), + draw->instanceCount, draw->firstInstance); + } else { + // This branch is only needed on OpenGL < 4.2 + glDrawElementsInstanced( + lastRenderPipeline->GetGLPrimitiveTopology(), draw->indexCount, + formatType, + reinterpret_cast(draw->firstIndex * formatSize + + indexBufferOffset), + draw->instanceCount); } - break; + } break; - case Command::TransitionTextureUsage: - { - TransitionTextureUsageCmd* cmd = mCommands.NextCommand(); + case Command::EndComputePass: { + mCommands.NextCommand(); + } break; - cmd->texture->UpdateUsageInternal(cmd->usage); + case Command::EndRenderPass: { + mCommands.NextCommand(); + } break; + + case Command::EndRenderSubpass: { + mCommands.NextCommand(); + glDeleteFramebuffers(1, ¤tFBO); + currentFBO = 0; + currentSubpass += 1; + } break; + + case Command::SetComputePipeline: { + SetComputePipelineCmd* cmd = mCommands.NextCommand(); + ToBackend(cmd->pipeline)->ApplyNow(); + lastGLPipeline = ToBackend(cmd->pipeline).Get(); + lastPipeline = ToBackend(cmd->pipeline).Get(); + pushConstants.OnSetPipeline(lastPipeline); + } break; + + case Command::SetRenderPipeline: { + SetRenderPipelineCmd* cmd = mCommands.NextCommand(); + ToBackend(cmd->pipeline)->ApplyNow(persistentPipelineState); + lastRenderPipeline = ToBackend(cmd->pipeline).Get(); + lastGLPipeline = ToBackend(cmd->pipeline).Get(); + lastPipeline = ToBackend(cmd->pipeline).Get(); + + pushConstants.OnSetPipeline(lastPipeline); + inputBuffers.OnSetPipeline(lastRenderPipeline); + } break; + + case Command::SetPushConstants: { + SetPushConstantsCmd* cmd = mCommands.NextCommand(); + uint32_t* data = mCommands.NextData(cmd->count); + pushConstants.OnSetPushConstants(cmd->stages, cmd->count, cmd->offset, data); + } break; + + case Command::SetStencilReference: { + SetStencilReferenceCmd* cmd = mCommands.NextCommand(); + persistentPipelineState.SetStencilReference(cmd->reference); + } break; + + case Command::SetBlendColor: { + SetBlendColorCmd* cmd = mCommands.NextCommand(); + glBlendColor(cmd->r, cmd->g, cmd->b, cmd->a); + } break; + + case Command::SetBindGroup: { + SetBindGroupCmd* cmd = mCommands.NextCommand(); + size_t groupIndex = cmd->index; + BindGroup* group = ToBackend(cmd->group.Get()); + + const auto& indices = + ToBackend(lastPipeline->GetLayout())->GetBindingIndexInfo()[groupIndex]; + const auto& layout = group->GetLayout()->GetBindingInfo(); + + for (uint32_t binding : IterateBitSet(layout.mask)) { + switch (layout.types[binding]) { + case nxt::BindingType::UniformBuffer: { + BufferView* view = + ToBackend(group->GetBindingAsBufferView(binding)); + GLuint buffer = ToBackend(view->GetBuffer())->GetHandle(); + GLuint uboIndex = indices[binding]; + + glBindBufferRange(GL_UNIFORM_BUFFER, uboIndex, buffer, + view->GetOffset(), view->GetSize()); + } break; + + case nxt::BindingType::Sampler: { + GLuint sampler = + ToBackend(group->GetBindingAsSampler(binding))->GetHandle(); + GLuint samplerIndex = indices[binding]; + + for (auto unit : + lastGLPipeline->GetTextureUnitsForSampler(samplerIndex)) { + glBindSampler(unit, sampler); + } + } break; + + case nxt::BindingType::SampledTexture: { + TextureView* view = + ToBackend(group->GetBindingAsTextureView(binding)); + Texture* texture = ToBackend(view->GetTexture()); + GLuint handle = texture->GetHandle(); + GLenum target = texture->GetGLTarget(); + GLuint textureIndex = indices[binding]; + + for (auto unit : + lastGLPipeline->GetTextureUnitsForTexture(textureIndex)) { + glActiveTexture(GL_TEXTURE0 + unit); + glBindTexture(target, handle); + } + } break; + + case nxt::BindingType::StorageBuffer: { + BufferView* view = + ToBackend(group->GetBindingAsBufferView(binding)); + GLuint buffer = ToBackend(view->GetBuffer())->GetHandle(); + GLuint ssboIndex = indices[binding]; + + glBindBufferRange(GL_SHADER_STORAGE_BUFFER, ssboIndex, buffer, + view->GetOffset(), view->GetSize()); + } break; + } } - break; + } break; + + case Command::SetIndexBuffer: { + SetIndexBufferCmd* cmd = mCommands.NextCommand(); + indexBufferOffset = cmd->offset; + inputBuffers.OnSetIndexBuffer(cmd->buffer.Get()); + } break; + + case Command::SetVertexBuffers: { + SetVertexBuffersCmd* cmd = mCommands.NextCommand(); + auto buffers = mCommands.NextData>(cmd->count); + auto offsets = mCommands.NextData(cmd->count); + inputBuffers.OnSetVertexBuffers(cmd->startSlot, cmd->count, buffers, offsets); + } break; + + case Command::TransitionBufferUsage: { + TransitionBufferUsageCmd* cmd = + mCommands.NextCommand(); + + cmd->buffer->UpdateUsageInternal(cmd->usage); + } break; + + case Command::TransitionTextureUsage: { + TransitionTextureUsageCmd* cmd = + mCommands.NextCommand(); + + cmd->texture->UpdateUsageInternal(cmd->usage); + } break; } } @@ -652,5 +638,4 @@ namespace opengl { glBindSampler(0, 0); } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/CommandBufferGL.h b/src/backend/opengl/CommandBufferGL.h index dcbe06f6fa..b87ffb1ca8 100644 --- a/src/backend/opengl/CommandBufferGL.h +++ b/src/backend/opengl/CommandBufferGL.h @@ -18,23 +18,21 @@ #include "backend/CommandAllocator.h" #include "backend/CommandBuffer.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class CommandBuffer : public CommandBufferBase { - public: - CommandBuffer(CommandBufferBuilder* builder); - ~CommandBuffer(); + public: + CommandBuffer(CommandBufferBuilder* builder); + ~CommandBuffer(); - void Execute(); + void Execute(); - private: - CommandIterator mCommands; + private: + CommandIterator mCommands; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_COMMANDBUFFERGL_H_ +#endif // BACKEND_OPENGL_COMMANDBUFFERGL_H_ diff --git a/src/backend/opengl/ComputePipelineGL.cpp b/src/backend/opengl/ComputePipelineGL.cpp index d2fd8ad0fb..e4638b34ff 100644 --- a/src/backend/opengl/ComputePipelineGL.cpp +++ b/src/backend/opengl/ComputePipelineGL.cpp @@ -14,8 +14,7 @@ #include "backend/opengl/ComputePipelineGL.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { ComputePipeline::ComputePipeline(ComputePipelineBuilder* builder) : ComputePipelineBase(builder), PipelineGL(this, builder) { @@ -25,5 +24,4 @@ namespace opengl { PipelineGL::ApplyNow(); } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/ComputePipelineGL.h b/src/backend/opengl/ComputePipelineGL.h index c0678c3db1..764e1aec84 100644 --- a/src/backend/opengl/ComputePipelineGL.h +++ b/src/backend/opengl/ComputePipelineGL.h @@ -21,17 +21,15 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class ComputePipeline : public ComputePipelineBase, public PipelineGL { - public: - ComputePipeline(ComputePipelineBuilder* builder); + public: + ComputePipeline(ComputePipelineBuilder* builder); - void ApplyNow(); + void ApplyNow(); }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_COMPUTEPIPELINEGL_H_ +#endif // BACKEND_OPENGL_COMPUTEPIPELINEGL_H_ diff --git a/src/backend/opengl/DepthStencilStateGL.cpp b/src/backend/opengl/DepthStencilStateGL.cpp index 1397670a46..0df1cf08f0 100644 --- a/src/backend/opengl/DepthStencilStateGL.cpp +++ b/src/backend/opengl/DepthStencilStateGL.cpp @@ -18,8 +18,7 @@ #include "backend/opengl/PersistentPipelineStateGL.h" #include "common/Assert.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { GLuint OpenGLCompareFunction(nxt::CompareFunction compareFunction) { @@ -67,17 +66,18 @@ namespace opengl { UNREACHABLE(); } } - } + } // namespace DepthStencilState::DepthStencilState(DepthStencilStateBuilder* builder) : DepthStencilStateBase(builder) { } - void DepthStencilState::ApplyNow(PersistentPipelineState &persistentPipelineState) const { + void DepthStencilState::ApplyNow(PersistentPipelineState& persistentPipelineState) const { auto& depthInfo = GetDepth(); // Depth writes only occur if depth is enabled - if (depthInfo.compareFunction == nxt::CompareFunction::Always && !depthInfo.depthWriteEnabled) { + if (depthInfo.compareFunction == nxt::CompareFunction::Always && + !depthInfo.depthWriteEnabled) { glDisable(GL_DEPTH_TEST); } else { glEnable(GL_DEPTH_TEST); @@ -101,22 +101,17 @@ namespace opengl { GLenum backCompareFunction = OpenGLCompareFunction(stencilInfo.back.compareFunction); GLenum frontCompareFunction = OpenGLCompareFunction(stencilInfo.front.compareFunction); - persistentPipelineState.SetStencilFuncsAndMask(backCompareFunction, frontCompareFunction, stencilInfo.readMask); + persistentPipelineState.SetStencilFuncsAndMask(backCompareFunction, frontCompareFunction, + stencilInfo.readMask); - glStencilOpSeparate(GL_BACK, - OpenGLStencilOperation(stencilInfo.back.stencilFail), - OpenGLStencilOperation(stencilInfo.back.depthFail), - OpenGLStencilOperation(stencilInfo.back.depthStencilPass) - ); - glStencilOpSeparate(GL_FRONT, - OpenGLStencilOperation(stencilInfo.front.stencilFail), - OpenGLStencilOperation(stencilInfo.front.depthFail), - OpenGLStencilOperation(stencilInfo.front.depthStencilPass) - ); + glStencilOpSeparate(GL_BACK, OpenGLStencilOperation(stencilInfo.back.stencilFail), + OpenGLStencilOperation(stencilInfo.back.depthFail), + OpenGLStencilOperation(stencilInfo.back.depthStencilPass)); + glStencilOpSeparate(GL_FRONT, OpenGLStencilOperation(stencilInfo.front.stencilFail), + OpenGLStencilOperation(stencilInfo.front.depthFail), + OpenGLStencilOperation(stencilInfo.front.depthStencilPass)); glStencilMask(stencilInfo.writeMask); - } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/DepthStencilStateGL.h b/src/backend/opengl/DepthStencilStateGL.h index 5c5d781651..5f920aab31 100644 --- a/src/backend/opengl/DepthStencilStateGL.h +++ b/src/backend/opengl/DepthStencilStateGL.h @@ -17,20 +17,18 @@ #include "backend/DepthStencilState.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class PersistentPipelineState; class DepthStencilState : public DepthStencilStateBase { - public: - DepthStencilState(DepthStencilStateBuilder* builder); + public: + DepthStencilState(DepthStencilStateBuilder* builder); - void ApplyNow(PersistentPipelineState &persistentPipelineState) const; + void ApplyNow(PersistentPipelineState& persistentPipelineState) const; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_DEPTHSTENCILSTATEGL_H_ +#endif // BACKEND_OPENGL_DEPTHSTENCILSTATEGL_H_ diff --git a/src/backend/opengl/GeneratedCodeIncludes.h b/src/backend/opengl/GeneratedCodeIncludes.h index a57f83307d..b47f055eaa 100644 --- a/src/backend/opengl/GeneratedCodeIncludes.h +++ b/src/backend/opengl/GeneratedCodeIncludes.h @@ -12,13 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "backend/opengl/OpenGLBackend.h" #include "backend/opengl/BlendStateGL.h" #include "backend/opengl/BufferGL.h" #include "backend/opengl/CommandBufferGL.h" #include "backend/opengl/ComputePipelineGL.h" #include "backend/opengl/DepthStencilStateGL.h" #include "backend/opengl/InputStateGL.h" +#include "backend/opengl/OpenGLBackend.h" #include "backend/opengl/PersistentPipelineStateGL.h" #include "backend/opengl/PipelineLayoutGL.h" #include "backend/opengl/RenderPipelineGL.h" diff --git a/src/backend/opengl/InputStateGL.cpp b/src/backend/opengl/InputStateGL.cpp index 957d1d0fd7..8bb04e532e 100644 --- a/src/backend/opengl/InputStateGL.cpp +++ b/src/backend/opengl/InputStateGL.cpp @@ -17,11 +17,9 @@ #include "backend/opengl/OpenGLBackend.h" #include "common/Assert.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { - InputState::InputState(InputStateBuilder* builder) - : InputStateBase(builder) { + InputState::InputState(InputStateBuilder* builder) : InputStateBase(builder) { glGenVertexArrays(1, &mVertexArrayObject); glBindVertexArray(mVertexArrayObject); auto& attributesSetMask = GetAttributesSetMask(); @@ -61,5 +59,4 @@ namespace opengl { return mVertexArrayObject; } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/InputStateGL.h b/src/backend/opengl/InputStateGL.h index e3401ad378..2c0446edad 100644 --- a/src/backend/opengl/InputStateGL.h +++ b/src/backend/opengl/InputStateGL.h @@ -19,24 +19,22 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class InputState : public InputStateBase { - public: - InputState(InputStateBuilder* builder); + public: + InputState(InputStateBuilder* builder); - std::bitset GetAttributesUsingInput(uint32_t slot) const; - GLuint GetVAO(); + std::bitset GetAttributesUsingInput(uint32_t slot) const; + GLuint GetVAO(); - private: - GLuint mVertexArrayObject; - std::array, kMaxVertexInputs> attributesUsingInput; + private: + GLuint mVertexArrayObject; + std::array, kMaxVertexInputs> attributesUsingInput; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_INPUTSTATEGL_H_ +#endif // BACKEND_OPENGL_INPUTSTATEGL_H_ diff --git a/src/backend/opengl/OpenGLBackend.cpp b/src/backend/opengl/OpenGLBackend.cpp index 96e68661a3..79ec008285 100644 --- a/src/backend/opengl/OpenGLBackend.cpp +++ b/src/backend/opengl/OpenGLBackend.cpp @@ -22,13 +22,12 @@ #include "backend/opengl/InputStateGL.h" #include "backend/opengl/PipelineLayoutGL.h" #include "backend/opengl/RenderPipelineGL.h" +#include "backend/opengl/SamplerGL.h" #include "backend/opengl/ShaderModuleGL.h" #include "backend/opengl/SwapChainGL.h" -#include "backend/opengl/SamplerGL.h" #include "backend/opengl/TextureGL.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { nxtProcTable GetNonValidatingProcs(); nxtProcTable GetValidatingProcs(); @@ -109,8 +108,7 @@ namespace opengl { // Bind Group - BindGroup::BindGroup(BindGroupBuilder* builder) - : BindGroupBase(builder) { + BindGroup::BindGroup(BindGroupBuilder* builder) : BindGroupBase(builder) { } // Bind Group Layout @@ -121,17 +119,15 @@ namespace opengl { // Framebuffer - Framebuffer::Framebuffer(FramebufferBuilder* builder) - : FramebufferBase(builder) { + Framebuffer::Framebuffer(FramebufferBuilder* builder) : FramebufferBase(builder) { } // Queue - Queue::Queue(QueueBuilder* builder) - : QueueBase(builder) { + Queue::Queue(QueueBuilder* builder) : QueueBase(builder) { } - void Queue::Submit(uint32_t numCommands, CommandBuffer* const * commands) { + void Queue::Submit(uint32_t numCommands, CommandBuffer* const* commands) { for (uint32_t i = 0; i < numCommands; ++i) { commands[i]->Execute(); } @@ -139,9 +135,7 @@ namespace opengl { // RenderPass - RenderPass::RenderPass(RenderPassBuilder* builder) - : RenderPassBase(builder) { + RenderPass::RenderPass(RenderPassBuilder* builder) : RenderPassBase(builder) { } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/OpenGLBackend.h b/src/backend/opengl/OpenGLBackend.h index a4449e1e33..5a9be0e509 100644 --- a/src/backend/opengl/OpenGLBackend.h +++ b/src/backend/opengl/OpenGLBackend.h @@ -17,12 +17,12 @@ #include "nxt/nxtcpp.h" -#include "backend/Buffer.h" -#include "backend/BlendState.h" #include "backend/BindGroup.h" #include "backend/BindGroupLayout.h" -#include "backend/Device.h" +#include "backend/BlendState.h" +#include "backend/Buffer.h" #include "backend/DepthStencilState.h" +#include "backend/Device.h" #include "backend/Framebuffer.h" #include "backend/InputState.h" #include "backend/Queue.h" @@ -31,8 +31,7 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class BindGroup; class BindGroupLayout; @@ -79,66 +78,65 @@ namespace opengl { using TextureViewType = TextureView; }; - template + template auto ToBackend(T&& common) -> decltype(ToBackendBase(common)) { return ToBackendBase(common); } // Definition of backend types class Device : public DeviceBase { - public: - BindGroupBase* CreateBindGroup(BindGroupBuilder* builder) override; - BindGroupLayoutBase* CreateBindGroupLayout(BindGroupLayoutBuilder* builder) override; - BlendStateBase* CreateBlendState(BlendStateBuilder* builder) override; - BufferBase* CreateBuffer(BufferBuilder* builder) override; - BufferViewBase* CreateBufferView(BufferViewBuilder* builder) override; - CommandBufferBase* CreateCommandBuffer(CommandBufferBuilder* builder) override; - ComputePipelineBase* CreateComputePipeline(ComputePipelineBuilder* builder) override; - DepthStencilStateBase* CreateDepthStencilState(DepthStencilStateBuilder* builder) override; - InputStateBase* CreateInputState(InputStateBuilder* builder) override; - FramebufferBase* CreateFramebuffer(FramebufferBuilder* builder) override; - PipelineLayoutBase* CreatePipelineLayout(PipelineLayoutBuilder* builder) override; - QueueBase* CreateQueue(QueueBuilder* builder) override; - RenderPassBase* CreateRenderPass(RenderPassBuilder* builder) override; - RenderPipelineBase* CreateRenderPipeline(RenderPipelineBuilder* builder) override; - SamplerBase* CreateSampler(SamplerBuilder* builder) override; - ShaderModuleBase* CreateShaderModule(ShaderModuleBuilder* builder) override; - SwapChainBase* CreateSwapChain(SwapChainBuilder* builder) override; - TextureBase* CreateTexture(TextureBuilder* builder) override; - TextureViewBase* CreateTextureView(TextureViewBuilder* builder) override; + public: + BindGroupBase* CreateBindGroup(BindGroupBuilder* builder) override; + BindGroupLayoutBase* CreateBindGroupLayout(BindGroupLayoutBuilder* builder) override; + BlendStateBase* CreateBlendState(BlendStateBuilder* builder) override; + BufferBase* CreateBuffer(BufferBuilder* builder) override; + BufferViewBase* CreateBufferView(BufferViewBuilder* builder) override; + CommandBufferBase* CreateCommandBuffer(CommandBufferBuilder* builder) override; + ComputePipelineBase* CreateComputePipeline(ComputePipelineBuilder* builder) override; + DepthStencilStateBase* CreateDepthStencilState(DepthStencilStateBuilder* builder) override; + InputStateBase* CreateInputState(InputStateBuilder* builder) override; + FramebufferBase* CreateFramebuffer(FramebufferBuilder* builder) override; + PipelineLayoutBase* CreatePipelineLayout(PipelineLayoutBuilder* builder) override; + QueueBase* CreateQueue(QueueBuilder* builder) override; + RenderPassBase* CreateRenderPass(RenderPassBuilder* builder) override; + RenderPipelineBase* CreateRenderPipeline(RenderPipelineBuilder* builder) override; + SamplerBase* CreateSampler(SamplerBuilder* builder) override; + ShaderModuleBase* CreateShaderModule(ShaderModuleBuilder* builder) override; + SwapChainBase* CreateSwapChain(SwapChainBuilder* builder) override; + TextureBase* CreateTexture(TextureBuilder* builder) override; + TextureViewBase* CreateTextureView(TextureViewBuilder* builder) override; - void TickImpl() override; + void TickImpl() override; }; class BindGroup : public BindGroupBase { - public: - BindGroup(BindGroupBuilder* builder); + public: + BindGroup(BindGroupBuilder* builder); }; class BindGroupLayout : public BindGroupLayoutBase { - public: - BindGroupLayout(BindGroupLayoutBuilder* builder); + public: + BindGroupLayout(BindGroupLayoutBuilder* builder); }; class Framebuffer : public FramebufferBase { - public: - Framebuffer(FramebufferBuilder* builder); + public: + Framebuffer(FramebufferBuilder* builder); }; class Queue : public QueueBase { - public: - Queue(QueueBuilder* builder); + public: + Queue(QueueBuilder* builder); - // NXT API - void Submit(uint32_t numCommands, CommandBuffer* const * commands); + // NXT API + void Submit(uint32_t numCommands, CommandBuffer* const* commands); }; class RenderPass : public RenderPassBase { - public: - RenderPass(RenderPassBuilder* builder); + public: + RenderPass(RenderPassBuilder* builder); }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_OPENGLBACKEND_H_ +#endif // BACKEND_OPENGL_OPENGLBACKEND_H_ diff --git a/src/backend/opengl/PersistentPipelineStateGL.cpp b/src/backend/opengl/PersistentPipelineStateGL.cpp index bec9bfa0c4..7f0f54cade 100644 --- a/src/backend/opengl/PersistentPipelineStateGL.cpp +++ b/src/backend/opengl/PersistentPipelineStateGL.cpp @@ -16,14 +16,15 @@ #include "backend/opengl/OpenGLBackend.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { void PersistentPipelineState::SetDefaultState() { CallGLStencilFunc(); } - void PersistentPipelineState::SetStencilFuncsAndMask(GLenum stencilBackCompareFunction, GLenum stencilFrontCompareFunction, uint32_t stencilReadMask) { + void PersistentPipelineState::SetStencilFuncsAndMask(GLenum stencilBackCompareFunction, + GLenum stencilFrontCompareFunction, + uint32_t stencilReadMask) { if (mStencilBackCompareFunction == stencilBackCompareFunction && mStencilFrontCompareFunction == stencilFrontCompareFunction && mStencilReadMask == stencilReadMask) { @@ -46,15 +47,10 @@ namespace opengl { } void PersistentPipelineState::CallGLStencilFunc() { - glStencilFuncSeparate(GL_BACK, - mStencilBackCompareFunction, - mStencilReference, - mStencilReadMask); - glStencilFuncSeparate(GL_FRONT, - mStencilFrontCompareFunction, - mStencilReference, - mStencilReadMask); + glStencilFuncSeparate(GL_BACK, mStencilBackCompareFunction, mStencilReference, + mStencilReadMask); + glStencilFuncSeparate(GL_FRONT, mStencilFrontCompareFunction, mStencilReference, + mStencilReadMask); } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/PersistentPipelineStateGL.h b/src/backend/opengl/PersistentPipelineStateGL.h index ef6eddff0e..a084a4277e 100644 --- a/src/backend/opengl/PersistentPipelineStateGL.h +++ b/src/backend/opengl/PersistentPipelineStateGL.h @@ -19,25 +19,25 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class PersistentPipelineState { - public: - void SetDefaultState(); - void SetStencilFuncsAndMask(GLenum stencilBackCompareFunction, GLenum stencilFrontCompareFunction, uint32_t stencilReadMask); - void SetStencilReference(uint32_t stencilReference); + public: + void SetDefaultState(); + void SetStencilFuncsAndMask(GLenum stencilBackCompareFunction, + GLenum stencilFrontCompareFunction, + uint32_t stencilReadMask); + void SetStencilReference(uint32_t stencilReference); - private: - void CallGLStencilFunc(); + private: + void CallGLStencilFunc(); - GLenum mStencilBackCompareFunction = GL_ALWAYS; - GLenum mStencilFrontCompareFunction = GL_ALWAYS; - GLuint mStencilReadMask = 0xffffffff; - GLuint mStencilReference = 0; + GLenum mStencilBackCompareFunction = GL_ALWAYS; + GLenum mStencilFrontCompareFunction = GL_ALWAYS; + GLuint mStencilReadMask = 0xffffffff; + GLuint mStencilReference = 0; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_PERSISTENTPIPELINESTATE_H_ +#endif // BACKEND_OPENGL_PERSISTENTPIPELINESTATE_H_ diff --git a/src/backend/opengl/PipelineGL.cpp b/src/backend/opengl/PipelineGL.cpp index 26e06a6699..b33875e1b9 100644 --- a/src/backend/opengl/PipelineGL.cpp +++ b/src/backend/opengl/PipelineGL.cpp @@ -22,8 +22,7 @@ #include #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { @@ -40,7 +39,7 @@ namespace opengl { } } - } + } // namespace PipelineGL::PipelineGL(PipelineBase* parent, PipelineBuilder* builder) { auto CreateShader = [](GLenum type, const char* source) -> GLuint { @@ -65,7 +64,8 @@ namespace opengl { return shader; }; - auto FillPushConstants = [](const ShaderModule* module, GLPushConstantInfo* info, GLuint program) { + auto FillPushConstants = [](const ShaderModule* module, GLPushConstantInfo* info, + GLuint program) { const auto& moduleInfo = module->GetPushConstants(); for (uint32_t i = 0; i < moduleInfo.names.size(); i++) { (*info)[i] = -1; @@ -119,7 +119,8 @@ namespace opengl { glUseProgram(mProgram); - // The uniforms are part of the program state so we can pre-bind buffer units, texture units etc. + // The uniforms are part of the program state so we can pre-bind buffer units, texture units + // etc. const auto& layout = ToBackend(parent->GetLayout()); const auto& indices = layout->GetBindingIndexInfo(); @@ -133,25 +134,22 @@ namespace opengl { std::string name = GetBindingName(group, binding); switch (groupInfo.types[binding]) { - case nxt::BindingType::UniformBuffer: - { - GLint location = glGetUniformBlockIndex(mProgram, name.c_str()); - glUniformBlockBinding(mProgram, location, indices[group][binding]); - } - break; + case nxt::BindingType::UniformBuffer: { + GLint location = glGetUniformBlockIndex(mProgram, name.c_str()); + glUniformBlockBinding(mProgram, location, indices[group][binding]); + } break; - case nxt::BindingType::StorageBuffer: - { - GLuint location = glGetProgramResourceIndex(mProgram, GL_SHADER_STORAGE_BLOCK, name.c_str()); - glShaderStorageBlockBinding(mProgram, location, indices[group][binding]); - } - break; + case nxt::BindingType::StorageBuffer: { + GLuint location = glGetProgramResourceIndex( + mProgram, GL_SHADER_STORAGE_BLOCK, name.c_str()); + glShaderStorageBlockBinding(mProgram, location, indices[group][binding]); + } break; case nxt::BindingType::Sampler: case nxt::BindingType::SampledTexture: - // These binding types are handled in the separate sampler and texture emulation + // These binding types are handled in the separate sampler and texture + // emulation break; - } } } @@ -176,18 +174,21 @@ namespace opengl { GLint location = glGetUniformLocation(mProgram, name.c_str()); glUniform1i(location, textureUnit); - GLuint samplerIndex = indices[combined.samplerLocation.group][combined.samplerLocation.binding]; + GLuint samplerIndex = + indices[combined.samplerLocation.group][combined.samplerLocation.binding]; mUnitsForSamplers[samplerIndex].push_back(textureUnit); - GLuint textureIndex = indices[combined.textureLocation.group][combined.textureLocation.binding]; + GLuint textureIndex = + indices[combined.textureLocation.group][combined.textureLocation.binding]; mUnitsForTextures[textureIndex].push_back(textureUnit); - textureUnit ++; + textureUnit++; } } } - const PipelineGL::GLPushConstantInfo& PipelineGL::GetGLPushConstants(nxt::ShaderStage stage) const { + const PipelineGL::GLPushConstantInfo& PipelineGL::GetGLPushConstants( + nxt::ShaderStage stage) const { return mGlPushConstants[stage]; } @@ -209,5 +210,4 @@ namespace opengl { glUseProgram(mProgram); } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/PipelineGL.h b/src/backend/opengl/PipelineGL.h index 1f1d09bcdf..d9c3ac3521 100644 --- a/src/backend/opengl/PipelineGL.h +++ b/src/backend/opengl/PipelineGL.h @@ -21,35 +21,34 @@ #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class PersistentPipelineState; class ShaderModule; class PipelineGL { - public: - PipelineGL(PipelineBase* parent, PipelineBuilder* builder); + public: + PipelineGL(PipelineBase* parent, PipelineBuilder* builder); - using GLPushConstantInfo = std::array; - using BindingLocations = std::array, kMaxBindGroups>; + using GLPushConstantInfo = std::array; + using BindingLocations = + std::array, kMaxBindGroups>; - const GLPushConstantInfo& GetGLPushConstants(nxt::ShaderStage stage) const; - const std::vector& GetTextureUnitsForSampler(GLuint index) const; - const std::vector& GetTextureUnitsForTexture(GLuint index) const; - GLuint GetProgramHandle() const; + const GLPushConstantInfo& GetGLPushConstants(nxt::ShaderStage stage) const; + const std::vector& GetTextureUnitsForSampler(GLuint index) const; + const std::vector& GetTextureUnitsForTexture(GLuint index) const; + GLuint GetProgramHandle() const; - void ApplyNow(); + void ApplyNow(); - private: - GLuint mProgram; - PerStage mGlPushConstants; - std::vector> mUnitsForSamplers; - std::vector> mUnitsForTextures; + private: + GLuint mProgram; + PerStage mGlPushConstants; + std::vector> mUnitsForSamplers; + std::vector> mUnitsForTextures; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_PIPELINEGL_H_ +#endif // BACKEND_OPENGL_PIPELINEGL_H_ diff --git a/src/backend/opengl/PipelineLayoutGL.cpp b/src/backend/opengl/PipelineLayoutGL.cpp index 7a2acd1503..c9c0b563ab 100644 --- a/src/backend/opengl/PipelineLayoutGL.cpp +++ b/src/backend/opengl/PipelineLayoutGL.cpp @@ -16,11 +16,9 @@ #include "backend/opengl/OpenGLBackend.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { - PipelineLayout::PipelineLayout(PipelineLayoutBuilder* builder) - : PipelineLayoutBase(builder) { + PipelineLayout::PipelineLayout(PipelineLayoutBuilder* builder) : PipelineLayoutBase(builder) { GLuint uboIndex = 0; GLuint samplerIndex = 0; GLuint sampledTextureIndex = 0; @@ -37,20 +35,20 @@ namespace opengl { switch (groupInfo.types[binding]) { case nxt::BindingType::UniformBuffer: mIndexInfo[group][binding] = uboIndex; - uboIndex ++; + uboIndex++; break; case nxt::BindingType::Sampler: mIndexInfo[group][binding] = samplerIndex; - samplerIndex ++; + samplerIndex++; break; case nxt::BindingType::SampledTexture: mIndexInfo[group][binding] = sampledTextureIndex; - sampledTextureIndex ++; + sampledTextureIndex++; break; case nxt::BindingType::StorageBuffer: mIndexInfo[group][binding] = ssboIndex; - ssboIndex ++; + ssboIndex++; break; } } @@ -76,5 +74,4 @@ namespace opengl { return mNumSampledTextures; } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/PipelineLayoutGL.h b/src/backend/opengl/PipelineLayoutGL.h index 2fdea3572d..3c60787a79 100644 --- a/src/backend/opengl/PipelineLayoutGL.h +++ b/src/backend/opengl/PipelineLayoutGL.h @@ -19,29 +19,28 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class PipelineLayout : public PipelineLayoutBase { - public: - PipelineLayout(PipelineLayoutBuilder* builder); + public: + PipelineLayout(PipelineLayoutBuilder* builder); - using BindingIndexInfo = std::array, kMaxBindGroups>; - const BindingIndexInfo& GetBindingIndexInfo() const; + using BindingIndexInfo = + std::array, kMaxBindGroups>; + const BindingIndexInfo& GetBindingIndexInfo() const; - GLuint GetTextureUnitsUsed() const; - size_t GetNumSamplers() const; - size_t GetNumSampledTextures() const; + GLuint GetTextureUnitsUsed() const; + size_t GetNumSamplers() const; + size_t GetNumSampledTextures() const; - private: - BindingIndexInfo mIndexInfo; - size_t mNumSamplers; - size_t mNumSampledTextures; + private: + BindingIndexInfo mIndexInfo; + size_t mNumSamplers; + size_t mNumSampledTextures; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_PIPELINELAYOUTGL_H_ +#endif // BACKEND_OPENGL_PIPELINELAYOUTGL_H_ diff --git a/src/backend/opengl/RenderPipelineGL.cpp b/src/backend/opengl/RenderPipelineGL.cpp index 7684f76bd7..5804d49b04 100644 --- a/src/backend/opengl/RenderPipelineGL.cpp +++ b/src/backend/opengl/RenderPipelineGL.cpp @@ -20,8 +20,7 @@ #include "backend/opengl/OpenGLBackend.h" #include "backend/opengl/PersistentPipelineStateGL.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { GLenum GLPrimitiveTopology(nxt::PrimitiveTopology primitiveTopology) { @@ -40,10 +39,11 @@ namespace opengl { UNREACHABLE(); } } - } + } // namespace RenderPipeline::RenderPipeline(RenderPipelineBuilder* builder) - : RenderPipelineBase(builder), PipelineGL(this, builder), + : RenderPipelineBase(builder), + PipelineGL(this, builder), mGlPrimitiveTopology(GLPrimitiveTopology(GetPrimitiveTopology())) { } @@ -51,7 +51,7 @@ namespace opengl { return mGlPrimitiveTopology; } - void RenderPipeline::ApplyNow(PersistentPipelineState &persistentPipelineState) { + void RenderPipeline::ApplyNow(PersistentPipelineState& persistentPipelineState) { PipelineGL::ApplyNow(); auto inputState = ToBackend(GetInputState()); @@ -68,5 +68,4 @@ namespace opengl { } } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/RenderPipelineGL.h b/src/backend/opengl/RenderPipelineGL.h index a45f06d348..542092cfc2 100644 --- a/src/backend/opengl/RenderPipelineGL.h +++ b/src/backend/opengl/RenderPipelineGL.h @@ -23,24 +23,22 @@ #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class PersistentPipelineState; class RenderPipeline : public RenderPipelineBase, public PipelineGL { - public: - RenderPipeline(RenderPipelineBuilder* builder); + public: + RenderPipeline(RenderPipelineBuilder* builder); - GLenum GetGLPrimitiveTopology() const; + GLenum GetGLPrimitiveTopology() const; - void ApplyNow(PersistentPipelineState &persistentPipelineState); + void ApplyNow(PersistentPipelineState& persistentPipelineState); - private: - GLenum mGlPrimitiveTopology; + private: + GLenum mGlPrimitiveTopology; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_RENDERPIPELINEGL_H_ +#endif // BACKEND_OPENGL_RENDERPIPELINEGL_H_ diff --git a/src/backend/opengl/SamplerGL.cpp b/src/backend/opengl/SamplerGL.cpp index b06c12f8aa..2da9b9d627 100644 --- a/src/backend/opengl/SamplerGL.cpp +++ b/src/backend/opengl/SamplerGL.cpp @@ -16,8 +16,7 @@ #include "common/Assert.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { GLenum MagFilterMode(nxt::FilterMode filter) { @@ -55,18 +54,17 @@ namespace opengl { UNREACHABLE(); } } - } + } // namespace - Sampler::Sampler(SamplerBuilder* builder) - : SamplerBase(builder) { + Sampler::Sampler(SamplerBuilder* builder) : SamplerBase(builder) { glGenSamplers(1, &mHandle); glSamplerParameteri(mHandle, GL_TEXTURE_MAG_FILTER, MagFilterMode(builder->GetMagFilter())); - glSamplerParameteri(mHandle, GL_TEXTURE_MIN_FILTER, MinFilterMode(builder->GetMinFilter(), builder->GetMipMapFilter())); + glSamplerParameteri(mHandle, GL_TEXTURE_MIN_FILTER, + MinFilterMode(builder->GetMinFilter(), builder->GetMipMapFilter())); } GLuint Sampler::GetHandle() const { return mHandle; } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/SamplerGL.h b/src/backend/opengl/SamplerGL.h index 1c56381022..36f823da6b 100644 --- a/src/backend/opengl/SamplerGL.h +++ b/src/backend/opengl/SamplerGL.h @@ -19,22 +19,20 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class Sampler : public SamplerBase { - public: - Sampler(SamplerBuilder* builder); + public: + Sampler(SamplerBuilder* builder); - GLuint GetHandle() const; + GLuint GetHandle() const; - private: - GLuint mHandle; + private: + GLuint mHandle; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_SAMPLERGL_H_ +#endif // BACKEND_OPENGL_SAMPLERGL_H_ diff --git a/src/backend/opengl/ShaderModuleGL.cpp b/src/backend/opengl/ShaderModuleGL.cpp index 654ac0c1f5..78ebad4c3e 100644 --- a/src/backend/opengl/ShaderModuleGL.cpp +++ b/src/backend/opengl/ShaderModuleGL.cpp @@ -21,8 +21,7 @@ #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { std::string GetBindingName(uint32_t group, uint32_t binding) { std::ostringstream o; @@ -30,12 +29,13 @@ namespace opengl { return o.str(); } - bool operator < (const BindingLocation& a, const BindingLocation& b) { + bool operator<(const BindingLocation& a, const BindingLocation& b) { return std::tie(a.group, a.binding) < std::tie(b.group, b.binding); } - bool operator < (const CombinedSampler& a, const CombinedSampler& b) { - return std::tie(a.samplerLocation, a.textureLocation) < std::tie(b.samplerLocation, b.textureLocation); + bool operator<(const CombinedSampler& a, const CombinedSampler& b) { + return std::tie(a.samplerLocation, a.textureLocation) < + std::tie(b.samplerLocation, b.textureLocation); } std::string CombinedSampler::GetName() const { @@ -46,8 +46,7 @@ namespace opengl { return o.str(); } - ShaderModule::ShaderModule(ShaderModuleBuilder* builder) - : ShaderModuleBase(builder) { + ShaderModule::ShaderModule(ShaderModuleBuilder* builder) : ShaderModuleBase(builder) { spirv_cross::CompilerGLSL compiler(builder->AcquireSpirv()); spirv_cross::CompilerGLSL::Options options; @@ -60,8 +59,8 @@ namespace opengl { options.vertex.flip_vert_y = true; compiler.set_options(options); - // Rename the push constant block to be prefixed with the shader stage type so that uniform names - // don't match between the FS and the VS. + // Rename the push constant block to be prefixed with the shader stage type so that uniform + // names don't match between the FS and the VS. const auto& resources = compiler.get_shader_resources(); if (resources.push_constant_buffers.size() > 0) { const char* prefix = nullptr; @@ -95,10 +94,14 @@ namespace opengl { mCombinedInfo.emplace_back(); auto& info = mCombinedInfo.back(); - info.samplerLocation.group = compiler.get_decoration(combined.sampler_id, spv::DecorationDescriptorSet); - info.samplerLocation.binding = compiler.get_decoration(combined.sampler_id, spv::DecorationBinding); - info.textureLocation.group = compiler.get_decoration(combined.image_id, spv::DecorationDescriptorSet); - info.textureLocation.binding = compiler.get_decoration(combined.image_id, spv::DecorationBinding); + info.samplerLocation.group = + compiler.get_decoration(combined.sampler_id, spv::DecorationDescriptorSet); + info.samplerLocation.binding = + compiler.get_decoration(combined.sampler_id, spv::DecorationBinding); + info.textureLocation.group = + compiler.get_decoration(combined.image_id, spv::DecorationDescriptorSet); + info.textureLocation.binding = + compiler.get_decoration(combined.image_id, spv::DecorationBinding); compiler.set_name(combined.combined_id, info.GetName()); } @@ -127,5 +130,4 @@ namespace opengl { return mCombinedInfo; } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/ShaderModuleGL.h b/src/backend/opengl/ShaderModuleGL.h index ccb2deb6d4..5951ece4bc 100644 --- a/src/backend/opengl/ShaderModuleGL.h +++ b/src/backend/opengl/ShaderModuleGL.h @@ -19,8 +19,7 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; @@ -30,30 +29,29 @@ namespace opengl { uint32_t group; uint32_t binding; }; - bool operator < (const BindingLocation& a, const BindingLocation& b); + bool operator<(const BindingLocation& a, const BindingLocation& b); struct CombinedSampler { BindingLocation samplerLocation; BindingLocation textureLocation; std::string GetName() const; }; - bool operator < (const CombinedSampler& a, const CombinedSampler& b); + bool operator<(const CombinedSampler& a, const CombinedSampler& b); class ShaderModule : public ShaderModuleBase { - public: - ShaderModule(ShaderModuleBuilder* builder); + public: + ShaderModule(ShaderModuleBuilder* builder); - using CombinedSamplerInfo = std::vector; + using CombinedSamplerInfo = std::vector; - const char* GetSource() const; - const CombinedSamplerInfo& GetCombinedSamplerInfo() const; + const char* GetSource() const; + const CombinedSamplerInfo& GetCombinedSamplerInfo() const; - private: - CombinedSamplerInfo mCombinedInfo; - std::string mGlslSource; + private: + CombinedSamplerInfo mCombinedInfo; + std::string mGlslSource; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_SHADERMODULEGL_H_ +#endif // BACKEND_OPENGL_SHADERMODULEGL_H_ diff --git a/src/backend/opengl/SwapChainGL.cpp b/src/backend/opengl/SwapChainGL.cpp index e37234bad6..6c5bf63c4b 100644 --- a/src/backend/opengl/SwapChainGL.cpp +++ b/src/backend/opengl/SwapChainGL.cpp @@ -19,11 +19,9 @@ #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { - SwapChain::SwapChain(SwapChainBuilder* builder) - : SwapChainBase(builder) { + SwapChain::SwapChain(SwapChainBuilder* builder) : SwapChainBase(builder) { const auto& im = GetImplementation(); im.Init(im.userData, nullptr); } @@ -43,5 +41,4 @@ namespace opengl { return new Texture(builder, nativeTexture); } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/SwapChainGL.h b/src/backend/opengl/SwapChainGL.h index 24741ff04d..03cf06e212 100644 --- a/src/backend/opengl/SwapChainGL.h +++ b/src/backend/opengl/SwapChainGL.h @@ -19,21 +19,19 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; class SwapChain : public SwapChainBase { - public: - SwapChain(SwapChainBuilder* builder); - ~SwapChain(); + public: + SwapChain(SwapChainBuilder* builder); + ~SwapChain(); - protected: - TextureBase* GetNextTextureImpl(TextureBuilder* builder) override; + protected: + TextureBase* GetNextTextureImpl(TextureBuilder* builder) override; }; -} -} +}} // namespace backend::opengl -#endif // BACKEND_OPENGL_SWAPCHAINGL_H_ +#endif // BACKEND_OPENGL_SWAPCHAINGL_H_ diff --git a/src/backend/opengl/TextureGL.cpp b/src/backend/opengl/TextureGL.cpp index d50efe2278..6625fafdd3 100644 --- a/src/backend/opengl/TextureGL.cpp +++ b/src/backend/opengl/TextureGL.cpp @@ -19,8 +19,7 @@ #include #include -namespace backend { -namespace opengl { +namespace backend { namespace opengl { namespace { @@ -43,7 +42,8 @@ namespace opengl { // This doesn't have an enum for the internal format in OpenGL. return {GL_NONE, GL_BGRA, GL_UNSIGNED_BYTE}; case nxt::TextureFormat::D32FloatS8Uint: - return {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV}; + return {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, + GL_FLOAT_32_UNSIGNED_INT_24_8_REV}; default: UNREACHABLE(); } @@ -55,12 +55,11 @@ namespace opengl { return handle; } - } + } // namespace // Texture - Texture::Texture(TextureBuilder* builder) - : Texture(builder, GenTexture()) { + Texture::Texture(TextureBuilder* builder) : Texture(builder, GenTexture()) { } Texture::Texture(TextureBuilder* builder, GLuint handle) @@ -76,7 +75,8 @@ namespace opengl { glBindTexture(mTarget, handle); for (uint32_t i = 0; i < levels; ++i) { - glTexImage2D(mTarget, i, formatInfo.internalFormat, width, height, 0, formatInfo.format, formatInfo.type, nullptr); + glTexImage2D(mTarget, i, formatInfo.internalFormat, width, height, 0, formatInfo.format, + formatInfo.type, nullptr); width = std::max(uint32_t(1), width / 2); height = std::max(uint32_t(1), height / 2); } @@ -87,7 +87,8 @@ namespace opengl { } Texture::~Texture() { - // TODO(kainino@chromium.org): delete texture (but only when not using the native texture constructor?) + // TODO(kainino@chromium.org): delete texture (but only when not using the native texture + // constructor?) } GLuint Texture::GetHandle() const { @@ -107,9 +108,7 @@ namespace opengl { // TextureView - TextureView::TextureView(TextureViewBuilder* builder) - : TextureViewBase(builder) { + TextureView::TextureView(TextureViewBuilder* builder) : TextureViewBase(builder) { } -} -} +}} // namespace backend::opengl diff --git a/src/backend/opengl/TextureGL.h b/src/backend/opengl/TextureGL.h index 648c5a11c0..a6583e8b9c 100644 --- a/src/backend/opengl/TextureGL.h +++ b/src/backend/opengl/TextureGL.h @@ -19,8 +19,7 @@ #include "glad/glad.h" -namespace backend { -namespace opengl { +namespace backend { namespace opengl { class Device; @@ -31,29 +30,28 @@ namespace opengl { }; class Texture : public TextureBase { - public: - Texture(TextureBuilder* builder); - Texture(TextureBuilder* builder, GLuint handle); - ~Texture(); + public: + Texture(TextureBuilder* builder); + Texture(TextureBuilder* builder, GLuint handle); + ~Texture(); - GLuint GetHandle() const; - GLenum GetGLTarget() const; - TextureFormatInfo GetGLFormat() const; + GLuint GetHandle() const; + GLenum GetGLTarget() const; + TextureFormatInfo GetGLFormat() const; - void TransitionUsageImpl(nxt::TextureUsageBit currentUsage, nxt::TextureUsageBit targetUsage) override; + void TransitionUsageImpl(nxt::TextureUsageBit currentUsage, + nxt::TextureUsageBit targetUsage) override; - private: - GLuint mHandle; - GLenum mTarget; + private: + GLuint mHandle; + GLenum mTarget; }; class TextureView : public TextureViewBase { - public: - TextureView(TextureViewBuilder* builder); + public: + TextureView(TextureViewBuilder* builder); }; +}} // namespace backend::opengl -} -} - -#endif // BACKEND_OPENGL_TEXTUREGL_H_ +#endif // BACKEND_OPENGL_TEXTUREGL_H_