kc3-lang/angle/src/libANGLE/renderer/ProgramImpl.h

• Show log

  Commit

• Hash : 192745a7
  Author :
  Date : 2016-12-22T15:58:21
  

  Add varying packing validation for WebGL.
  
  This CL moves the varying packing from the D3D layer up to Program.
  This is necessary for WebGL validation, and gives us consistency
  for the various back-ends. There may be some additional cleanup work
  on the VaryingPacking class, because it does some work that is D3D-
  specific.
  
  WebGL requires strict varying packing. Instead of allowing success
  unconditionally, it's an explicit error to succeed to pack a set of
  varyings that the sample algorithm would fail to pack.
  
  Introduce a new packing mode option to the varying packing class to
  handle this different packing style, while keeping our old more
  relaxed packing method for ES code.
  
  BUG=angleproject:1675
  
  Change-Id: I674ae685ba573cc2ad7d9dfb7441efa8cb2d55fc
  Reviewed-on: https://chromium-review.googlesource.com/423254
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/libANGLE/renderer/ProgramImpl.h

• //
  // Copyright 2014 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.
  //
  
  // ProgramImpl.h: Defines the abstract rx::ProgramImpl class.
  
  #ifndef LIBANGLE_RENDERER_PROGRAMIMPL_H_
  #define LIBANGLE_RENDERER_PROGRAMIMPL_H_
  
  #include "common/angleutils.h"
  #include "libANGLE/BinaryStream.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Program.h"
  #include "libANGLE/Shader.h"
  
  #include <map>
  
  namespace gl
  {
  class VaryingPacking;
  }
  
  namespace sh
  {
  struct BlockMemberInfo;
  }
  
  namespace rx
  {
  using LinkResult = gl::ErrorOrResult<bool>;
  
  class ContextImpl;
  
  class ProgramImpl : angle::NonCopyable
  {
    public:
      ProgramImpl(const gl::ProgramState &state) : mState(state) {}
      virtual ~ProgramImpl() {}
  
      virtual LinkResult load(const ContextImpl *contextImpl,
                              gl::InfoLog &infoLog,
                              gl::BinaryInputStream *stream)  = 0;
      virtual gl::Error save(gl::BinaryOutputStream *stream) = 0;
      virtual void setBinaryRetrievableHint(bool retrievable) = 0;
  
      virtual LinkResult link(const gl::ContextState &data,
                              const gl::VaryingPacking &packing,
                              gl::InfoLog &infoLog) = 0;
      virtual GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) = 0;
  
      virtual void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) = 0;
      virtual void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) = 0;
      virtual void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) = 0;
      virtual void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) = 0;
      virtual void setUniform1iv(GLint location, GLsizei count, const GLint *v) = 0;
      virtual void setUniform2iv(GLint location, GLsizei count, const GLint *v) = 0;
      virtual void setUniform3iv(GLint location, GLsizei count, const GLint *v) = 0;
      virtual void setUniform4iv(GLint location, GLsizei count, const GLint *v) = 0;
      virtual void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) = 0;
      virtual void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) = 0;
      virtual void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) = 0;
      virtual void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) = 0;
      virtual void setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
      virtual void setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = 0;
  
      // TODO: synchronize in syncState when dirty bits exist.
      virtual void setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding) = 0;
  
      // May only be called after a successful link operation.
      // Return false for inactive blocks.
      virtual bool getUniformBlockSize(const std::string &blockName, size_t *sizeOut) const = 0;
  
      // May only be called after a successful link operation.
      // Returns false for inactive members.
      virtual bool getUniformBlockMemberInfo(const std::string &memberUniformName,
                                             sh::BlockMemberInfo *memberInfoOut) const = 0;
      // CHROMIUM_path_rendering
      // Set parameters to control fragment shader input variable interpolation
      virtual void setPathFragmentInputGen(const std::string &inputName,
                                           GLenum genMode,
                                           GLint components,
                                           const GLfloat *coeffs) = 0;
  
    protected:
      const gl::ProgramState &mState;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_PROGRAMIMPL_H_
  

Download