kc3-lang/angle/src/libANGLE/renderer/ContextImpl.cpp

• Show log

  Commit

• Hash : b980c563
  Author :
  Date : 2018-11-27T11:34:27
  

  Reformat all cpp and h files.
  
  This applies git cl format --full to all ANGLE sources.
  
  Bug: angleproject:2986
  Change-Id: Ib504e618c1589332a37e97696cdc3515d739308f
  Reviewed-on: https://chromium-review.googlesource.com/c/1351367
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/ContextImpl.cpp

• //
  // Copyright 2016 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.
  //
  // ContextImpl:
  //   Implementation-specific functionality associated with a GL Context.
  //
  
  #include "libANGLE/renderer/ContextImpl.h"
  
  #include "libANGLE/Context.h"
  
  namespace rx
  {
  
  ContextImpl::ContextImpl(const gl::ContextState &state)
      : mState(state), mMemoryProgramCache(nullptr), mErrors(nullptr)
  {}
  
  ContextImpl::~ContextImpl() {}
  
  void ContextImpl::stencilFillPath(const gl::Path *path, GLenum fillMode, GLuint mask)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilStrokePath(const gl::Path *path, GLint reference, GLuint mask)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::coverFillPath(const gl::Path *path, GLenum coverMode)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::coverStrokePath(const gl::Path *path, GLenum coverMode)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilThenCoverFillPath(const gl::Path *path,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum coverMode)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilThenCoverStrokePath(const gl::Path *path,
                                               GLint reference,
                                               GLuint mask,
                                               GLenum coverMode)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::coverFillPathInstanced(const std::vector<gl::Path *> &paths,
                                           GLenum coverMode,
                                           GLenum transformType,
                                           const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::coverStrokePathInstanced(const std::vector<gl::Path *> &paths,
                                             GLenum coverMode,
                                             GLenum transformType,
                                             const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilFillPathInstanced(const std::vector<gl::Path *> &paths,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum transformType,
                                             const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilStrokePathInstanced(const std::vector<gl::Path *> &paths,
                                               GLint reference,
                                               GLuint mask,
                                               GLenum transformType,
                                               const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilThenCoverFillPathInstanced(const std::vector<gl::Path *> &paths,
                                                      GLenum coverMode,
                                                      GLenum fillMode,
                                                      GLuint mask,
                                                      GLenum transformType,
                                                      const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::stencilThenCoverStrokePathInstanced(const std::vector<gl::Path *> &paths,
                                                        GLenum coverMode,
                                                        GLint reference,
                                                        GLuint mask,
                                                        GLenum transformType,
                                                        const GLfloat *transformValues)
  {
      UNREACHABLE();
  }
  
  void ContextImpl::setMemoryProgramCache(gl::MemoryProgramCache *memoryProgramCache)
  {
      mMemoryProgramCache = memoryProgramCache;
  }
  
  void ContextImpl::setErrorSet(gl::ErrorSet *errorSet)
  {
      mErrors = errorSet;
  }
  
  void ContextImpl::handleError(GLenum errorCode,
                                const char *message,
                                const char *file,
                                const char *function,
                                unsigned int line)
  {
      std::stringstream errorStream;
      errorStream << "Internal error: " << gl::FmtHex(errorCode) << ", in " << file << ", "
                  << function << ":" << line << ". " << message;
  
      mErrors->handleError(gl::Error(errorCode, errorCode, errorStream.str()));
  }
  }  // namespace rx
  

Download