chromium/third_party/angle/src/libANGLE/renderer/gl/ProgramExecutableGL.cpp

//
// 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.cpp: Implementation of ProgramExecutableGL.

#include "libANGLE/renderer/gl/ProgramExecutableGL.h"

#include "common/string_utils.h"
#include "libANGLE/Context.h"
#include "libANGLE/Program.h"
#include "libANGLE/Uniform.h"
#include "libANGLE/renderer/gl/ContextGL.h"
#include "libANGLE/renderer/gl/FunctionsGL.h"
#include "libANGLE/renderer/gl/RendererGL.h"
#include "libANGLE/renderer/gl/StateManagerGL.h"

namespace rx
{
ProgramExecutableGL::ProgramExecutableGL(const gl::ProgramExecutable *executable)
    : … { … }

ProgramExecutableGL::~ProgramExecutableGL() { … }

void ProgramExecutableGL::destroy(const gl::Context *context) { … }

void ProgramExecutableGL::reset()
{ … }

void ProgramExecutableGL::postLink(const FunctionsGL *functions,
                                   StateManagerGL *stateManager,
                                   const angle::FeaturesGL &features,
                                   GLuint programID)
{ … }

void ProgramExecutableGL::updateEnabledClipDistances(uint8_t enabledClipDistancesPacked) const
{ … }

void ProgramExecutableGL::updateEmulatedClipOrigin(gl::ClipOrigin origin) const
{ … }

void ProgramExecutableGL::enableLayeredRenderingPath(int baseViewIndex) const
{ … }

void ProgramExecutableGL::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
{ … }

void ProgramExecutableGL::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
{ … }

void ProgramExecutableGL::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
{ … }

void ProgramExecutableGL::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
{ … }

void ProgramExecutableGL::setUniform1iv(GLint location, GLsizei count, const GLint *v)
{ … }

void ProgramExecutableGL::setUniform2iv(GLint location, GLsizei count, const GLint *v)
{ … }

void ProgramExecutableGL::setUniform3iv(GLint location, GLsizei count, const GLint *v)
{ … }

void ProgramExecutableGL::setUniform4iv(GLint location, GLsizei count, const GLint *v)
{ … }

void ProgramExecutableGL::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
{ … }

void ProgramExecutableGL::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
{ … }

void ProgramExecutableGL::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
{ … }

void ProgramExecutableGL::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
{ … }

void ProgramExecutableGL::setUniformMatrix2fv(GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix3fv(GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix4fv(GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix2x3fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix3x2fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix2x4fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix4x2fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix3x4fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::setUniformMatrix4x3fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{ … }

void ProgramExecutableGL::getUniformfv(const gl::Context *context,
                                       GLint location,
                                       GLfloat *params) const
{ … }

void ProgramExecutableGL::getUniformiv(const gl::Context *context,
                                       GLint location,
                                       GLint *params) const
{ … }

void ProgramExecutableGL::getUniformuiv(const gl::Context *context,
                                        GLint location,
                                        GLuint *params) const
{ … }

void ProgramExecutableGL::setUniformBlockBinding(GLuint uniformBlockIndex,
                                                 GLuint uniformBlockBinding)
{ … }

void ProgramExecutableGL::reapplyUBOBindings()
{ … }

void ProgramExecutableGL::syncUniformBlockBindings()
{ … }
}  // namespace rx