ProgramExecutableGL.h

Show log
Commit

Hash : 0c4d6446
Author :
Date : 2024-01-24T10:38:45

Rework uniform block <-> uniform buffer mapping

In GLES, the shader declares which buffer binding a block (uniform,
storage or atomic counter) is bound to.  For example:

layout(binding = 1) uniform ubo0 { ... };
layout(binding = 2) uniform ubo1 { ... };
layout(binding = 1) uniform ubo2 { ... };

In the above, ubo0 and ubo2 use data from the buffer bound to index 2
(through glBindBufferRange), while ubo1 uses data from the buffer bound
to index 1.  For uniform blocks in particular, omitting the binding
is allowed, in which case it is implicitly bound to buffer 0.

GLES allows uniform blocks (and only uniform blocks) to remap their
bindings through calls to glUniformBlockBinding.  This means that the
mapping of uniform blocks in the program (ubo0, ubo1, ubo2) to the
buffer bindings is not constant.  For storage blocks and atomic counter
buffers, this binding _is_ constant and is determined at link time.

At link time, the mapping of blocks to buffers is determined based on
values specified in the shaders.  This info is stored was stored in
gl::InterfaceBlock::binding (for UBOs and SSBOs), and
gl::AtomicCounterBuffer::binding.  For clarity, this change renames
these members to ...::inShaderBinding.

When glUniformBlockBinding is called, the mapping is updated.  Prior to
this change, gl::InterfaceBlock::binding was directly updated, trumping
the mapping determined at link time.  A bug here was that after a call
to glProgramBinary, GL expects the mappings to reset to their original
link-time values, but instead ANGLE restored the mappings to what was
configured at the time the binary was retrieved.

This change tracks the uniform block -> buffer binding mapping
separately from the link results so that the original values can be
restored during glProgramBinary.  In the process, the support data
structures for tracking this mapping are moved to ProgramExecutable and
the algorithms are simplified.  Program Pipeline Objects maintain this
mapping identically to Programs and no longer require a special and more
costly path when a buffer state changes.

This change prepares for but does not yet fix the more fundamental bug
that the dirty bits are tracked in the program executable instead of the
context state, which makes changes not propagate to all contexts
correctly.

Bug: angleproject:8493
Change-Id: Ib0999f49be24db06ebe9a4917d06b90af899611e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5235883
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>

Download

src/libANGLE/renderer/gl/ProgramExecutableGL.h

//
// Copyright 2023 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// ProgramExecutableGL.h: Implementation of ProgramExecutableImpl.

#ifndef LIBANGLE_RENDERER_GL_PROGRAMEXECUTABLEGL_H_
#define LIBANGLE_RENDERER_GL_PROGRAMEXECUTABLEGL_H_

#include "libANGLE/ProgramExecutable.h"
#include "libANGLE/renderer/ProgramExecutableImpl.h"

namespace angle
{
struct FeaturesGL;
}  // namespace angle

namespace rx
{
class FunctionsGL;
class StateManagerGL;

class ProgramExecutableGL : public ProgramExecutableImpl
{
  public:
    ProgramExecutableGL(const gl::ProgramExecutable *executable);
    ~ProgramExecutableGL() override;

    void destroy(const gl::Context *context) override;

    void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) override;
    void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) override;
    void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) override;
    void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) override;
    void setUniform1iv(GLint location, GLsizei count, const GLint *v) override;
    void setUniform2iv(GLint location, GLsizei count, const GLint *v) override;
    void setUniform3iv(GLint location, GLsizei count, const GLint *v) override;
    void setUniform4iv(GLint location, GLsizei count, const GLint *v) override;
    void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) override;
    void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) override;
    void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) override;
    void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) override;
    void setUniformMatrix2fv(GLint location,
                             GLsizei count,
                             GLboolean transpose,
                             const GLfloat *value) override;
    void setUniformMatrix3fv(GLint location,
                             GLsizei count,
                             GLboolean transpose,
                             const GLfloat *value) override;
    void setUniformMatrix4fv(GLint location,
                             GLsizei count,
                             GLboolean transpose,
                             const GLfloat *value) override;
    void setUniformMatrix2x3fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
    void setUniformMatrix3x2fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
    void setUniformMatrix2x4fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
    void setUniformMatrix4x2fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
    void setUniformMatrix3x4fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
    void setUniformMatrix4x3fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;

    void getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const override;
    void getUniformiv(const gl::Context *context, GLint location, GLint *params) const override;
    void getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const override;

    void updateEnabledClipDistances(uint8_t enabledClipDistancesPacked) const;

    void updateEmulatedClipOrigin(gl::ClipOrigin origin) const;

    void enableLayeredRenderingPath(int baseViewIndex) const;

    void syncUniformBlockBindings();

    GLuint getProgramID() const { return mProgramID; }

  private:
    friend class ProgramGL;

    void reset();
    void postLink(const FunctionsGL *functions,
                  StateManagerGL *stateManager,
                  const angle::FeaturesGL &features,
                  GLuint programID);

    // Helper function, makes it simpler to type.
    GLint uniLoc(GLint glLocation) const { return mUniformRealLocationMap[glLocation]; }

    void setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding);
    void reapplyUBOBindings();

    std::vector<GLint> mUniformRealLocationMap;
    std::vector<GLuint> mUniformBlockRealLocationMap;

    bool mHasAppliedTransformFeedbackVaryings;

    GLint mClipDistanceEnabledUniformLocation;

    GLint mClipOriginUniformLocation;

    GLint mMultiviewBaseViewLayerIndexUniformLocation;

    // Indiciates which uniform blocks have had their bindings changed since last sync.  These
    // changes are a result of calls to glUniformBlockBinding, and only the GL backend needs to
    // directly act on them (which is why it's not tracked by the front-end, the other backends
    // combine this info with the actual buffer bindings).
    angle::BitSet<gl::IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS>
        mDirtyUniformBlockBindings;

    // The program for which the executable was built
    GLuint mProgramID;
    const FunctionsGL *mFunctions;
    StateManagerGL *mStateManager;
};

}  // namespace rx

#endif  // LIBANGLE_RENDERER_GL_PROGRAMEXECUTABLEGL_H_

Download