chromium/third_party/angle/src/libANGLE/ProgramPipeline.cpp

//
// Copyright 2017 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.
//

// ProgramPipeline.cpp: Implements the gl::ProgramPipeline class.
// Implements GL program pipeline objects and related functionality.
// [OpenGL ES 3.1] section 7.4 page 105.

#include "libANGLE/ProgramPipeline.h"

#include <algorithm>

#include "libANGLE/Context.h"
#include "libANGLE/Program.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/renderer/ContextImpl.h"
#include "libANGLE/renderer/ProgramPipelineImpl.h"

namespace gl
{

ProgramPipelineState::ProgramPipelineState(rx::GLImplFactory *factory)
    : … { … }

ProgramPipelineState::~ProgramPipelineState() { … }

const std::string &ProgramPipelineState::getLabel() const
{ … }

void ProgramPipelineState::activeShaderProgram(Program *shaderProgram)
{ … }

SharedProgramExecutable ProgramPipelineState::makeNewExecutable(
    rx::GLImplFactory *factory,
    ShaderMap<SharedProgramExecutable> &&ppoProgramExecutables)
{ … }

void ProgramPipelineState::useProgramStage(const Context *context,
                                           const ShaderType shaderType,
                                           Program *shaderProgram,
                                           angle::ObserverBinding *programObserverBinding,
                                           angle::ObserverBinding *programExecutableObserverBinding)
{ … }

void ProgramPipelineState::useProgramStages(
    const Context *context,
    const ShaderBitSet &shaderTypes,
    Program *shaderProgram,
    std::vector<angle::ObserverBinding> *programObserverBindings,
    std::vector<angle::ObserverBinding> *programExecutableObserverBindings)
{ … }

bool ProgramPipelineState::usesShaderProgram(ShaderProgramID programId) const
{ … }

void ProgramPipelineState::updateExecutableTextures()
{ … }

void ProgramPipelineState::updateExecutableSpecConstUsageBits()
{ … }

ProgramPipeline::ProgramPipeline(rx::GLImplFactory *factory, ProgramPipelineID handle)
    : … { … }

ProgramPipeline::~ProgramPipeline()
{ … }

void ProgramPipeline::onDestroy(const Context *context)
{ … }

void ProgramPipelineState::destroyDiscardedExecutables(const Context *context)
{ … }

angle::Result ProgramPipeline::setLabel(const Context *context, const std::string &label)
{ … }

const std::string &ProgramPipeline::getLabel() const
{ … }

rx::ProgramPipelineImpl *ProgramPipeline::getImplementation() const
{ … }

void ProgramPipeline::activeShaderProgram(Program *shaderProgram)
{ … }

angle::Result ProgramPipeline::useProgramStages(const Context *context,
                                                GLbitfield stages,
                                                Program *shaderProgram)
{ … }

void ProgramPipeline::updateLinkedShaderStages()
{ … }

void ProgramPipeline::updateExecutableAttributes()
{ … }

void ProgramPipeline::updateTransformFeedbackMembers()
{ … }

void ProgramPipeline::updateShaderStorageBlocks()
{ … }

void ProgramPipeline::updateImageBindings()
{ … }

void ProgramPipeline::updateExecutableGeometryProperties()
{ … }

void ProgramPipeline::updateExecutableTessellationProperties()
{ … }

void ProgramPipeline::updateFragmentInoutRangeAndEnablesPerSampleShading()
{ … }

void ProgramPipeline::updateLinkedVaryings()
{ … }

void ProgramPipeline::updateExecutable()
{ … }

void ProgramPipeline::resolveAttachedPrograms(const Context *context)
{ … }

// The attached shaders are checked for linking errors by matching up their variables.
// Uniform, input and output variables get collected.
// The code gets compiled into binaries.
angle::Result ProgramPipeline::link(const Context *context)
{ … }

int ProgramPipeline::getInfoLogLength() const
{ … }

void ProgramPipeline::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
{ … }

bool ProgramPipeline::linkVaryings()
{ … }

void ProgramPipeline::validate(const Context *context)
{ … }

void ProgramPipeline::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{ … }
}  // namespace gl