kc3-lang/angle/util/EGLWindow.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Austin Kinross
  Date : 2016-02-08 12:29:08
  Hash : 2a63b3f8
  Message : Re-land "Implement EGL_experimental_present_path_angle" - Re-land with clang fix. This allows ANGLE to render directly onto a D3D swapchain in the correct orientation when using the D3D11 renderer. The trick is to add an extra uniform to each shader which takes either the value +1.0 or -1.0. When rendering to a texture, ANGLE sets this value to -1.0. When rendering to the default framebuffer, ANGLE sets this value to +1.0. ANGLE multiplies vertex positions by this value in the VS to invert rendering when appropriate. It also corrects other state (e.g. viewport/scissor rect) and shader built-in values (e.g. gl_FragCoord). This saves a substantial amount of GPU time and lowers power consumption. For example, the old method (where ANGLE renders all content onto an offscreen texture, and then copies/inverts this onto the swapchain at eglSwapBuffers() time) uses about 20% of the GPU each frame on a Lumia 630. Verification: + dEQP GL ES2 tests pass when "present path fast" is enabled + all ANGLE_end2end_tests pass when "present path fast" is enabled BUG=angleproject:1219 Change-Id: I56b339897828753a616d7bae837a2f354dba9c63 Reviewed-on: https://chromium-review.googlesource.com/326730 Tryjob-Request: Austin Kinross <aukinros@microsoft.com> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>

• util/EGLWindow.h

• //
  // Copyright (c) 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.
  //
  
  #ifndef UTIL_EGLWINDOW_H_
  #define UTIL_EGLWINDOW_H_
  
  #include <list>
  #include <memory>
  #include <stdint.h>
  #include <string>
  
  #include <GLES2/gl2.h>
  #include <GLES2/gl2ext.h>
  #include <GLES3/gl3.h>
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  
  #include "common/angleutils.h"
  
  class OSWindow;
  
  // A hidden define used in some renderers (currently D3D-only)
  // to init a no-op renderer. Useful for performance testing.
  #ifndef EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE
  #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE 0x6AC0
  #endif
  
  struct EGLPlatformParameters
  {
      EGLint renderer;
      EGLint majorVersion;
      EGLint minorVersion;
      EGLint deviceType;
      EGLint presentPath;
  
      EGLPlatformParameters();
      explicit EGLPlatformParameters(EGLint renderer);
      EGLPlatformParameters(EGLint renderer, EGLint majorVersion, EGLint minorVersion, EGLint deviceType);
      EGLPlatformParameters(EGLint renderer,
                            EGLint majorVersion,
                            EGLint minorVersion,
                            EGLint deviceType,
                            EGLint presentPath);
  };
  
  bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
  bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
  
  class EGLWindow : angle::NonCopyable
  {
    public:
      EGLWindow(EGLint glesMajorVersion,
                EGLint glesMinorVersion,
                const EGLPlatformParameters &platform);
  
      ~EGLWindow();
  
      void setConfigRedBits(int bits) { mRedBits = bits; }
      void setConfigGreenBits(int bits) { mGreenBits = bits; }
      void setConfigBlueBits(int bits) { mBlueBits = bits; }
      void setConfigAlphaBits(int bits) { mAlphaBits = bits; }
      void setConfigDepthBits(int bits) { mDepthBits = bits; }
      void setConfigStencilBits(int bits) { mStencilBits = bits; }
      void setMultisample(bool multisample) { mMultisample = multisample; }
      void setDebugEnabled(bool debug) { mDebug = debug; }
      void setNoErrorEnabled(bool noError) { mNoError = noError; }
      void setSwapInterval(EGLint swapInterval) { mSwapInterval = swapInterval; }
  
      static EGLBoolean FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config);
  
      void swap();
  
      EGLint getClientMajorVersion() const { return mClientMajorVersion; }
      EGLint getClientMinorVersion() const { return mClientMinorVersion; }
      const EGLPlatformParameters &getPlatform() const { return mPlatform; }
      EGLConfig getConfig() const;
      EGLDisplay getDisplay() const;
      EGLSurface getSurface() const;
      EGLContext getContext() const;
      int getConfigRedBits() const { return mRedBits; }
      int getConfigGreenBits() const { return mGreenBits; }
      int getConfigBlueBits() const { return mBlueBits; }
      int getConfigAlphaBits() const { return mAlphaBits; }
      int getConfigDepthBits() const { return mDepthBits; }
      int getConfigStencilBits() const { return mStencilBits; }
      bool isMultisample() const { return mMultisample; }
      bool isDebugEnabled() const { return mDebug; }
      EGLint getSwapInterval() const { return mSwapInterval; }
  
      bool initializeGL(OSWindow *osWindow);
      void destroyGL();
      bool isGLInitialized() const;
  
    private:
      EGLConfig mConfig;
      EGLDisplay mDisplay;
      EGLSurface mSurface;
      EGLContext mContext;
  
      EGLint mClientMajorVersion;
      EGLint mClientMinorVersion;
      EGLPlatformParameters mPlatform;
      int mRedBits;
      int mGreenBits;
      int mBlueBits;
      int mAlphaBits;
      int mDepthBits;
      int mStencilBits;
      bool mMultisample;
      bool mDebug;
      bool mNoError;
      EGLint mSwapInterval;
  };
  
  #endif // UTIL_EGLWINDOW_H_