| // Copyright 2017 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "dawn/native/opengl/RenderPipelineGL.h" |
| |
| #include "dawn/native/opengl/DeviceGL.h" |
| #include "dawn/native/opengl/Forward.h" |
| #include "dawn/native/opengl/PersistentPipelineStateGL.h" |
| #include "dawn/native/opengl/UtilsGL.h" |
| |
| namespace dawn::native::opengl { |
| |
| namespace { |
| |
| GLenum GLPrimitiveTopology(wgpu::PrimitiveTopology primitiveTopology) { |
| switch (primitiveTopology) { |
| case wgpu::PrimitiveTopology::PointList: |
| return GL_POINTS; |
| case wgpu::PrimitiveTopology::LineList: |
| return GL_LINES; |
| case wgpu::PrimitiveTopology::LineStrip: |
| return GL_LINE_STRIP; |
| case wgpu::PrimitiveTopology::TriangleList: |
| return GL_TRIANGLES; |
| case wgpu::PrimitiveTopology::TriangleStrip: |
| return GL_TRIANGLE_STRIP; |
| case wgpu::PrimitiveTopology::Undefined: |
| break; |
| } |
| DAWN_UNREACHABLE(); |
| } |
| |
| MaybeError ApplyFrontFaceAndCulling(const OpenGLFunctions& gl, |
| wgpu::FrontFace face, |
| wgpu::CullMode mode) { |
| // Note that we invert winding direction in OpenGL. Because Y axis is up in OpenGL, |
| // which is different from WebGPU and other backends (Y axis is down). |
| GLenum direction = (face == wgpu::FrontFace::CCW) ? GL_CW : GL_CCW; |
| DAWN_GL_TRY(gl, FrontFace(direction)); |
| |
| if (mode == wgpu::CullMode::None) { |
| DAWN_GL_TRY(gl, Disable(GL_CULL_FACE)); |
| } else { |
| DAWN_GL_TRY(gl, Enable(GL_CULL_FACE)); |
| |
| GLenum cullMode = (mode == wgpu::CullMode::Front) ? GL_FRONT : GL_BACK; |
| DAWN_GL_TRY(gl, CullFace(cullMode)); |
| } |
| |
| return {}; |
| } |
| |
| GLenum GLBlendFactor(wgpu::BlendFactor factor, bool alpha) { |
| switch (factor) { |
| case wgpu::BlendFactor::Zero: |
| return GL_ZERO; |
| case wgpu::BlendFactor::One: |
| return GL_ONE; |
| case wgpu::BlendFactor::Src: |
| return GL_SRC_COLOR; |
| case wgpu::BlendFactor::OneMinusSrc: |
| return GL_ONE_MINUS_SRC_COLOR; |
| case wgpu::BlendFactor::SrcAlpha: |
| return GL_SRC_ALPHA; |
| case wgpu::BlendFactor::OneMinusSrcAlpha: |
| return GL_ONE_MINUS_SRC_ALPHA; |
| case wgpu::BlendFactor::Dst: |
| return GL_DST_COLOR; |
| case wgpu::BlendFactor::OneMinusDst: |
| return GL_ONE_MINUS_DST_COLOR; |
| case wgpu::BlendFactor::DstAlpha: |
| return GL_DST_ALPHA; |
| case wgpu::BlendFactor::OneMinusDstAlpha: |
| return GL_ONE_MINUS_DST_ALPHA; |
| case wgpu::BlendFactor::SrcAlphaSaturated: |
| return GL_SRC_ALPHA_SATURATE; |
| case wgpu::BlendFactor::Constant: |
| return alpha ? GL_CONSTANT_ALPHA : GL_CONSTANT_COLOR; |
| case wgpu::BlendFactor::OneMinusConstant: |
| return alpha ? GL_ONE_MINUS_CONSTANT_ALPHA : GL_ONE_MINUS_CONSTANT_COLOR; |
| case wgpu::BlendFactor::Src1: |
| return GL_SRC1_COLOR; |
| case wgpu::BlendFactor::OneMinusSrc1: |
| return GL_ONE_MINUS_SRC1_COLOR; |
| case wgpu::BlendFactor::Src1Alpha: |
| return GL_SRC1_ALPHA; |
| case wgpu::BlendFactor::OneMinusSrc1Alpha: |
| return GL_ONE_MINUS_SRC1_ALPHA; |
| case wgpu::BlendFactor::Undefined: |
| break; |
| } |
| DAWN_UNREACHABLE(); |
| } |
| |
| GLenum GLBlendMode(wgpu::BlendOperation operation) { |
| switch (operation) { |
| case wgpu::BlendOperation::Add: |
| return GL_FUNC_ADD; |
| case wgpu::BlendOperation::Subtract: |
| return GL_FUNC_SUBTRACT; |
| case wgpu::BlendOperation::ReverseSubtract: |
| return GL_FUNC_REVERSE_SUBTRACT; |
| case wgpu::BlendOperation::Min: |
| return GL_MIN; |
| case wgpu::BlendOperation::Max: |
| return GL_MAX; |
| case wgpu::BlendOperation::Undefined: |
| break; |
| } |
| DAWN_UNREACHABLE(); |
| } |
| |
| MaybeError ApplyColorState(const OpenGLFunctions& gl, |
| ColorAttachmentIndex attachment, |
| const ColorTargetState* state) { |
| GLuint colorBuffer = static_cast<GLuint>(static_cast<uint8_t>(attachment)); |
| if (state->blend != nullptr) { |
| DAWN_GL_TRY(gl, Enablei(GL_BLEND, colorBuffer)); |
| DAWN_GL_TRY(gl, |
| BlendEquationSeparatei(colorBuffer, GLBlendMode(state->blend->color.operation), |
| GLBlendMode(state->blend->alpha.operation))); |
| DAWN_GL_TRY( |
| gl, BlendFuncSeparatei(colorBuffer, GLBlendFactor(state->blend->color.srcFactor, false), |
| GLBlendFactor(state->blend->color.dstFactor, false), |
| GLBlendFactor(state->blend->alpha.srcFactor, true), |
| GLBlendFactor(state->blend->alpha.dstFactor, true))); |
| } else { |
| DAWN_GL_TRY(gl, Disablei(GL_BLEND, colorBuffer)); |
| } |
| DAWN_GL_TRY(gl, ColorMaski(colorBuffer, state->writeMask & wgpu::ColorWriteMask::Red, |
| state->writeMask & wgpu::ColorWriteMask::Green, |
| state->writeMask & wgpu::ColorWriteMask::Blue, |
| state->writeMask & wgpu::ColorWriteMask::Alpha)); |
| return {}; |
| } |
| |
| MaybeError ApplyColorState(const OpenGLFunctions& gl, const ColorTargetState* state) { |
| if (state->blend != nullptr) { |
| DAWN_GL_TRY(gl, Enable(GL_BLEND)); |
| DAWN_GL_TRY(gl, BlendEquationSeparate(GLBlendMode(state->blend->color.operation), |
| GLBlendMode(state->blend->alpha.operation))); |
| DAWN_GL_TRY(gl, BlendFuncSeparate(GLBlendFactor(state->blend->color.srcFactor, false), |
| GLBlendFactor(state->blend->color.dstFactor, false), |
| GLBlendFactor(state->blend->alpha.srcFactor, true), |
| GLBlendFactor(state->blend->alpha.dstFactor, true))); |
| } else { |
| DAWN_GL_TRY(gl, Disable(GL_BLEND)); |
| } |
| DAWN_GL_TRY(gl, ColorMask(state->writeMask & wgpu::ColorWriteMask::Red, |
| state->writeMask & wgpu::ColorWriteMask::Green, |
| state->writeMask & wgpu::ColorWriteMask::Blue, |
| state->writeMask & wgpu::ColorWriteMask::Alpha)); |
| return {}; |
| } |
| |
| bool Equal(const BlendComponent& lhs, const BlendComponent& rhs) { |
| return lhs.operation == rhs.operation && lhs.srcFactor == rhs.srcFactor && |
| lhs.dstFactor == rhs.dstFactor; |
| } |
| |
| GLuint OpenGLStencilOperation(wgpu::StencilOperation stencilOperation) { |
| switch (stencilOperation) { |
| case wgpu::StencilOperation::Keep: |
| return GL_KEEP; |
| case wgpu::StencilOperation::Zero: |
| return GL_ZERO; |
| case wgpu::StencilOperation::Replace: |
| return GL_REPLACE; |
| case wgpu::StencilOperation::Invert: |
| return GL_INVERT; |
| case wgpu::StencilOperation::IncrementClamp: |
| return GL_INCR; |
| case wgpu::StencilOperation::DecrementClamp: |
| return GL_DECR; |
| case wgpu::StencilOperation::IncrementWrap: |
| return GL_INCR_WRAP; |
| case wgpu::StencilOperation::DecrementWrap: |
| return GL_DECR_WRAP; |
| case wgpu::StencilOperation::Undefined: |
| break; |
| } |
| DAWN_UNREACHABLE(); |
| } |
| |
| } // anonymous namespace |
| |
| // static |
| Ref<RenderPipeline> RenderPipeline::CreateUninitialized( |
| Device* device, |
| const UnpackedPtr<RenderPipelineDescriptor>& descriptor) { |
| return AcquireRef(new RenderPipeline(device, descriptor)); |
| } |
| |
| RenderPipeline::RenderPipeline(Device* device, |
| const UnpackedPtr<RenderPipelineDescriptor>& descriptor) |
| : RenderPipelineBase(device, descriptor), |
| mVertexArrayObject(0), |
| mGlPrimitiveTopology(GLPrimitiveTopology(GetPrimitiveTopology())) {} |
| |
| MaybeError RenderPipeline::InitializeImpl() { |
| if (UsesVertexIndex()) { |
| mImmediateMask |= GetImmediateConstantBlockBits( |
| offsetof(RenderImmediateConstants, firstVertex), kImmediateConstantElementByteSize); |
| } |
| if (UsesInstanceIndex()) { |
| mImmediateMask |= GetImmediateConstantBlockBits( |
| offsetof(RenderImmediateConstants, firstInstance), kImmediateConstantElementByteSize); |
| } |
| if (UsesFragDepth()) { |
| mImmediateMask |= GetImmediateConstantBlockBits( |
| offsetof(RenderImmediateConstants, clampFragDepth), sizeof(ClampFragDepthArgs)); |
| } |
| return ToBackend(GetDevice()) |
| ->EnqueueGL([self = Ref<RenderPipeline>(this)](const OpenGLFunctions& gl) -> MaybeError { |
| VertexAttributeMask bgraSwizzleAttributes = {}; |
| for (VertexAttributeLocation i : self->GetAttributeLocationsUsed()) { |
| bgraSwizzleAttributes.set( |
| i, self->GetAttribute(i).format == wgpu::VertexFormat::Unorm8x4BGRA); |
| } |
| |
| DAWN_TRY(self->InitializeBase(gl, ToBackend(self->GetLayout()), self->GetAllStages(), |
| self->mImmediateMask, bgraSwizzleAttributes)); |
| DAWN_TRY(self->CreateVAOForVertexState(gl)); |
| return {}; |
| }); |
| } |
| |
| RenderPipeline::~RenderPipeline() = default; |
| |
| void RenderPipeline::DestroyImpl(DestroyReason reason) { |
| RenderPipelineBase::DestroyImpl(reason); |
| IgnoreErrors(ToBackend(GetDevice()) |
| ->EnqueueDestroyGL(this, &RenderPipeline::GetVertexArrayObject, reason, |
| [](const OpenGLFunctions& gl, GLuint vao) -> MaybeError { |
| DAWN_GL_TRY_IGNORE_ERRORS(gl, |
| DeleteVertexArrays(1, &vao)); |
| DAWN_GL_TRY_IGNORE_ERRORS(gl, BindVertexArray(0)); |
| return {}; |
| })); |
| IgnoreErrors( |
| ToBackend(GetDevice()) |
| ->EnqueueDestroyGL(this, &RenderPipeline::GetProgramHandle, reason, |
| [](const OpenGLFunctions& gl, GLuint program) -> MaybeError { |
| DAWN_GL_TRY_IGNORE_ERRORS(gl, DeleteProgram(program)); |
| return {}; |
| })); |
| } |
| |
| GLenum RenderPipeline::GetGLPrimitiveTopology() const { |
| return mGlPrimitiveTopology; |
| } |
| |
| GLuint RenderPipeline::GetProgramHandle() const { |
| return mProgram; |
| } |
| |
| GLuint RenderPipeline::GetVertexArrayObject() const { |
| return mVertexArrayObject; |
| } |
| |
| VertexAttributeMask RenderPipeline::GetAttributesUsingVertexBuffer(VertexBufferSlot slot) const { |
| DAWN_ASSERT(!IsError()); |
| return mAttributesUsingVertexBuffer[slot]; |
| } |
| |
| MaybeError RenderPipeline::CreateVAOForVertexState(const OpenGLFunctions& gl) { |
| DAWN_GL_TRY(gl, GenVertexArrays(1, &mVertexArrayObject)); |
| DAWN_GL_TRY(gl, BindVertexArray(mVertexArrayObject)); |
| |
| for (VertexAttributeLocation location : GetAttributeLocationsUsed()) { |
| const auto& attribute = GetAttribute(location); |
| GLuint glAttrib = static_cast<GLuint>(static_cast<uint8_t>(location)); |
| DAWN_GL_TRY(gl, EnableVertexAttribArray(glAttrib)); |
| |
| mAttributesUsingVertexBuffer[attribute.vertexBufferSlot][location] = true; |
| const VertexBufferInfo& vertexBuffer = GetVertexBuffer(attribute.vertexBufferSlot); |
| |
| if (vertexBuffer.arrayStride == 0) { |
| // Emulate a stride of zero (constant vertex attribute) by |
| // setting the attribute instance divisor to a huge number. |
| DAWN_GL_TRY(gl, VertexAttribDivisor(glAttrib, 0xffffffff)); |
| } else { |
| switch (vertexBuffer.stepMode) { |
| case wgpu::VertexStepMode::Vertex: |
| break; |
| case wgpu::VertexStepMode::Instance: |
| DAWN_GL_TRY(gl, VertexAttribDivisor(glAttrib, 1)); |
| break; |
| case wgpu::VertexStepMode::Undefined: |
| DAWN_UNREACHABLE(); |
| } |
| } |
| } |
| |
| return {}; |
| } |
| |
| MaybeError RenderPipeline::ApplyNow(const OpenGLFunctions& gl, |
| PersistentPipelineState& persistentPipelineState) { |
| DAWN_TRY(PipelineGL::ApplyNow(gl, ToBackend(GetLayout()))); |
| |
| DAWN_ASSERT(mVertexArrayObject); |
| DAWN_GL_TRY(gl, BindVertexArray(mVertexArrayObject)); |
| |
| DAWN_TRY(ApplyFrontFaceAndCulling(gl, GetFrontFace(), GetCullMode())); |
| |
| DAWN_TRY(ApplyDepthStencilState(gl, &persistentPipelineState)); |
| |
| DAWN_GL_TRY(gl, SampleMaski(0, GetSampleMask())); |
| if (IsAlphaToCoverageEnabled()) { |
| DAWN_GL_TRY(gl, Enable(GL_SAMPLE_ALPHA_TO_COVERAGE)); |
| } else { |
| DAWN_GL_TRY(gl, Disable(GL_SAMPLE_ALPHA_TO_COVERAGE)); |
| } |
| |
| if (IsDepthBiasEnabled()) { |
| DAWN_GL_TRY(gl, Enable(GL_POLYGON_OFFSET_FILL)); |
| float depthBias = GetDepthBias(); |
| if (GetDevice()->IsToggleEnabled(Toggle::GLDepthBiasModifier)) { |
| // There is an ambiguity in the GL and Vulkan specs with respect to |
| // depthBias: If a depth value lies between 2^n and 2^(n+1), is the |
| // "exponent of the depth value" n or n+1? Empirically, desktop GL drivers use |
| // n+1, while the WebGPU CTS is expecting n. Scaling the depth |
| // bias value by 0.5 gives results in line with other backends. |
| // See: https://gitlab.khronos.org/Tracker/vk-gl-cts/-/issues/4169 |
| // See also the GL ES 3.1 spec, section "13.5.2 Depth Offset". |
| depthBias *= 0.5f; |
| } |
| float slopeScale = GetDepthBiasSlopeScale(); |
| if (gl.PolygonOffsetClamp != nullptr) { |
| DAWN_GL_TRY(gl, PolygonOffsetClamp(slopeScale, depthBias, GetDepthBiasClamp())); |
| } else { |
| DAWN_GL_TRY(gl, PolygonOffset(slopeScale, depthBias)); |
| } |
| } else { |
| DAWN_GL_TRY(gl, Disable(GL_POLYGON_OFFSET_FILL)); |
| } |
| |
| if (!GetDevice()->IsToggleEnabled(Toggle::DisableIndexedDrawBuffers)) { |
| for (auto attachmentSlot : GetColorAttachmentsMask()) { |
| DAWN_TRY(ApplyColorState(gl, attachmentSlot, GetColorTargetState(attachmentSlot))); |
| } |
| } else { |
| const ColorTargetState* prevDescriptor = nullptr; |
| for (auto attachmentSlot : GetColorAttachmentsMask()) { |
| const ColorTargetState* descriptor = GetColorTargetState(attachmentSlot); |
| if (!prevDescriptor) { |
| DAWN_TRY(ApplyColorState(gl, descriptor)); |
| prevDescriptor = descriptor; |
| } else if ((descriptor->blend == nullptr) != (prevDescriptor->blend == nullptr)) { |
| // TODO(crbug.com/dawn/582): GLES < 3.2 does not support different blend states |
| // per color target. Add validation to prevent this as it is not. |
| DAWN_ASSERT(false); |
| } else if (descriptor->blend != nullptr) { |
| if (!Equal(descriptor->blend->alpha, prevDescriptor->blend->alpha) || |
| !Equal(descriptor->blend->color, prevDescriptor->blend->color) || |
| descriptor->writeMask != prevDescriptor->writeMask) { |
| // TODO(crbug.com/dawn/582) |
| DAWN_ASSERT(false); |
| } |
| } |
| } |
| } |
| |
| return {}; |
| } |
| |
| MaybeError RenderPipeline::ApplyDepthStencilState( |
| const OpenGLFunctions& gl, |
| PersistentPipelineState* persistentPipelineState) { |
| const DepthStencilState* descriptor = GetDepthStencilState(); |
| |
| // Depth writes only occur if depth is enabled |
| if (descriptor->depthCompare == wgpu::CompareFunction::Always && |
| descriptor->depthWriteEnabled != wgpu::OptionalBool::True) { |
| DAWN_GL_TRY(gl, Disable(GL_DEPTH_TEST)); |
| } else { |
| DAWN_GL_TRY(gl, Enable(GL_DEPTH_TEST)); |
| } |
| |
| if (descriptor->depthWriteEnabled == wgpu::OptionalBool::True) { |
| DAWN_GL_TRY(gl, DepthMask(GL_TRUE)); |
| } else { |
| DAWN_GL_TRY(gl, DepthMask(GL_FALSE)); |
| } |
| |
| DAWN_GL_TRY(gl, DepthFunc(ToOpenGLCompareFunction(descriptor->depthCompare))); |
| |
| if (UsesStencil()) { |
| DAWN_GL_TRY(gl, Enable(GL_STENCIL_TEST)); |
| } else { |
| DAWN_GL_TRY(gl, Disable(GL_STENCIL_TEST)); |
| } |
| |
| GLenum backCompareFunction = ToOpenGLCompareFunction(descriptor->stencilBack.compare); |
| GLenum frontCompareFunction = ToOpenGLCompareFunction(descriptor->stencilFront.compare); |
| DAWN_TRY(persistentPipelineState->SetStencilFuncsAndMask( |
| gl, backCompareFunction, frontCompareFunction, descriptor->stencilReadMask)); |
| |
| DAWN_GL_TRY(gl, |
| StencilOpSeparate(GL_BACK, OpenGLStencilOperation(descriptor->stencilBack.failOp), |
| OpenGLStencilOperation(descriptor->stencilBack.depthFailOp), |
| OpenGLStencilOperation(descriptor->stencilBack.passOp))); |
| DAWN_GL_TRY(gl, |
| StencilOpSeparate(GL_FRONT, OpenGLStencilOperation(descriptor->stencilFront.failOp), |
| OpenGLStencilOperation(descriptor->stencilFront.depthFailOp), |
| OpenGLStencilOperation(descriptor->stencilFront.passOp))); |
| |
| DAWN_GL_TRY(gl, StencilMask(descriptor->stencilWriteMask)); |
| |
| return {}; |
| } |
| |
| } // namespace dawn::native::opengl |
