kc3-lang/angle/samples/multiple_contexts/MultipleContexts.cpp

• Show log

  Commit

• Hash : 5a65a2b1
  Author :
  Date : 2022-07-06T11:46:17
  

  Fix samples' arguments to SampleApplication
  
  Two new parameters were added in
  https://chromium-review.googlesource.com/c/angle/angle/+/3664916 with
  default values, but not all samples were updated to accomodate them.  As
  a result, many samples passed in the major version for client type and
  thus couldn't run.
  
  This change introduces an enum class for the client type + version to
  make sure such a mistake is impossible.
  
  Bug: angleproject:7360
  Change-Id: I450edee612d08a7b67530b61615f63268fefb200
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3748413
  Auto-Submit: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Lingfeng Yang <lfy@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• samples/multiple_contexts/MultipleContexts.cpp

• //
  // Copyright 2021 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.
  //
  // Demonstrates GLES usage with two contexts, one uploading texture data.
  
  #include "SampleApplication.h"
  #include "util/random_utils.h"
  #include "util/shader_utils.h"
  #include "util/test_utils.h"
  
  #include <array>
  #include <mutex>
  #include <queue>
  #include <thread>
  
  struct TextureAndFence
  {
      GLuint textureID;
      GLsync fenceSync;
  };
  
  constexpr GLuint64 kTimeout         = 10000000;
  static constexpr GLint kTextureSize = 2;
  constexpr size_t kWindowWidth       = 400;
  constexpr size_t kWindowHeight      = 300;
  
  void UpdateThreadLoop(EGLDisplay display,
                        EGLConfig config,
                        EGLContext shareContext,
                        std::mutex *updateThreadMutex,
                        std::queue<TextureAndFence> *updateThreadQueue,
                        std::mutex *mainThreadMutex,
                        std::queue<TextureAndFence> *mainThreadQueue)
  {
      angle::RNG rng;
  
      EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_NONE};
      EGLContext context      = eglCreateContext(display, config, shareContext, contextAttribs);
  
      EGLint surfaceAttribs[] = {EGL_NONE};
      EGLSurface surface      = eglCreatePbufferSurface(display, config, surfaceAttribs);
  
      eglMakeCurrent(display, surface, surface, context);
  
      for (;;)
      {
          bool hasUpdate = false;
          TextureAndFence textureAndFence;
  
          {
              std::lock_guard<std::mutex> lock(*updateThreadMutex);
              if (!updateThreadQueue->empty())
              {
                  textureAndFence = updateThreadQueue->back();
                  hasUpdate       = true;
                  updateThreadQueue->pop();
              }
          }
  
          if (hasUpdate)
          {
              if (textureAndFence.textureID == 0)
              {
                  // Signal from the main thread to stop execution.
                  break;
              }
  
              glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
              glDeleteSync(textureAndFence.fenceSync);
              glBindTexture(GL_TEXTURE_2D, textureAndFence.textureID);
  
              std::vector<uint8_t> bytes(3, 0);
              FillVectorWithRandomUBytes(&rng, &bytes);
              bytes.push_back(255);
  
              std::vector<uint8_t> textureData;
              for (GLint x = 0; x < kTextureSize; ++x)
              {
                  for (GLint y = 0; y < kTextureSize; ++y)
                  {
                      textureData.insert(textureData.end(), bytes.begin(), bytes.end());
                  }
              }
  
              glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
                              GL_UNSIGNED_BYTE, textureData.data());
  
              GLsync mainThreadSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
  
              {
                  std::lock_guard<std::mutex> lock(*mainThreadMutex);
                  mainThreadQueue->push({textureAndFence.textureID, mainThreadSync});
              }
          }
  
          angle::Sleep(200);
      }
  
      eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
      eglDestroySurface(display, surface);
      eglDestroyContext(display, context);
  }
  
  class MultipleContextsSample : public SampleApplication
  {
    public:
      MultipleContextsSample(int argc, char **argv)
          : SampleApplication("MultipleContexts",
                              argc,
                              argv,
                              ClientType::ES3_0,
                              kWindowWidth,
                              kWindowHeight)
      {}
  
      bool initialize() override
      {
          // Initialize some textures and send them to the update thread.
          glGenTextures(kNumTextures, mTextures.data());
  
          for (GLuint texture : mTextures)
          {
              glBindTexture(GL_TEXTURE_2D, texture);
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kTextureSize, kTextureSize, 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, nullptr);
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
              glBindTexture(GL_TEXTURE_2D, 0);
              GLsync fenceSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
  
              mUpdateThreadQueue.push({texture, fenceSync});
          }
  
          mUpdateThread.reset(new std::thread(UpdateThreadLoop, getDisplay(), getConfig(),
                                              getContext(), &mUpdateThreadMutex, &mUpdateThreadQueue,
                                              &mMainThreadMutex, &mMainThreadQueue));
  
          mProgram = CompileProgram(angle::essl1_shaders::vs::Texture2D(),
                                    angle::essl1_shaders::fs::Texture2D());
          glUseProgram(mProgram);
          glEnableVertexAttribArray(0);
  
          glGenBuffers(1, &mVertexBuffer);
          glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
          glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * 6, nullptr, GL_DYNAMIC_DRAW);
  
          glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
  
          return true;
      }
  
      void destroy() override
      {
          {
              // Signal the worker thread to stop execution.
              std::lock_guard<std::mutex> lock(mUpdateThreadMutex);
              mUpdateThreadQueue.push({0, 0});
          }
  
          for (;;)
          {
              {
                  std::lock_guard<std::mutex> mainLock(mMainThreadMutex);
                  if (mMainThreadQueue.empty())
                  {
                      std::lock_guard<std::mutex> updateLock(mUpdateThreadMutex);
                      if (mUpdateThreadQueue.empty())
                      {
                          break;
                      }
                  }
                  else
                  {
                      TextureAndFence textureAndFence = mMainThreadQueue.back();
                      mMainThreadQueue.pop();
                      glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
                      glDeleteSync(textureAndFence.fenceSync);
                  }
              }
          }
  
          glDeleteTextures(kNumTextures, mTextures.data());
          glDeleteProgram(mProgram);
          glDeleteBuffers(1, &mVertexBuffer);
      }
  
      void draw() override
      {
          bool hasUpdate = false;
          TextureAndFence textureAndFence;
          while (!hasUpdate)
          {
              {
                  std::lock_guard<std::mutex> lock(mMainThreadMutex);
                  if (!mMainThreadQueue.empty())
                  {
                      hasUpdate       = true;
                      textureAndFence = mMainThreadQueue.back();
                      mMainThreadQueue.pop();
                  }
              }
          }
  
          glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
          glDeleteSync(textureAndFence.fenceSync);
          glBindTexture(GL_TEXTURE_2D, textureAndFence.textureID);
  
          constexpr size_t kNumRows    = 3;
          constexpr size_t kNumCols    = 4;
          constexpr size_t kTileHeight = kWindowHeight / kNumRows;
          constexpr size_t kTileWidth  = kWindowWidth / kNumCols;
  
          size_t tileX = mDrawCount % kNumCols;
          size_t tileY = (mDrawCount / kNumCols) % kNumRows;
  
          mDrawCount++;
  
          GLfloat tileX0 = static_cast<float>(tileX) / static_cast<float>(kNumCols);
          GLfloat tileY0 = static_cast<float>(tileY) / static_cast<float>(kNumRows);
          GLfloat tileX1 = tileX0 + static_cast<float>(kTileWidth) / static_cast<float>(kWindowWidth);
          GLfloat tileY1 =
              tileY0 + static_cast<float>(kTileHeight) / static_cast<float>(kWindowHeight);
  
          tileX0 = tileX0 * 2.0f - 1.0f;
          tileX1 = tileX1 * 2.0f - 1.0f;
          tileY0 = tileY0 * 2.0f - 1.0f;
          tileY1 = tileY1 * 2.0f - 1.0f;
  
          std::vector<GLfloat> vertices = {tileX0, tileY0, tileX0, tileY1, tileX1, tileY0,
                                           tileX1, tileY0, tileX1, tileY1, tileX0, tileY1};
  
          glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices[0]) * vertices.size(), vertices.data());
  
          glClear(GL_COLOR_BUFFER_BIT);
          glDrawArrays(GL_TRIANGLES, 0, 6);
  
          GLsync drawSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
          {
              std::lock_guard<std::mutex> lock(mUpdateThreadMutex);
              mUpdateThreadQueue.push({textureAndFence.textureID, drawSync});
          }
      }
  
    private:
      std::unique_ptr<std::thread> mUpdateThread;
  
      static constexpr GLuint kNumTextures = 4;
      std::array<GLuint, kNumTextures> mTextures;
  
      GLuint mProgram      = 0;
      GLuint mVertexBuffer = 0;
  
      std::mutex mUpdateThreadMutex;
      std::queue<TextureAndFence> mUpdateThreadQueue;
      std::mutex mMainThreadMutex;
      std::queue<TextureAndFence> mMainThreadQueue;
      size_t mDrawCount = 0;
  };
  
  int main(int argc, char **argv)
  {
      MultipleContextsSample app(argc, argv);
      return app.run();
  }
  

Download