kc3-lang/angle/samples/torus_lighting/TorusBufferStorage.cpp

• Show log

  Commit

• Hash : 3369f720
  Author :
  Date : 2021-09-08T15:23:22
  

  samples: Add torus bufferstorage ES3 sample.
  
  Adds a sample that uses GL_EXT_buffer_storage and the
  GL_MAP_COHERENT_BIT_EXT to update colors.
  
  Expose IsGLExtensionEnabled in SampleApplication.
  
  Bug: angleproject:5857
  Change-Id: I1ba2962cda939da527a17c49a3ef430a69486c52
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3168628
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Lubosz Sarnecki <lubosz.sarnecki@collabora.com>
  

Download

• samples/torus_lighting/TorusBufferStorage.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.
  //
  
  // Based on CubeMapActivity.java from The Android Open Source Project ApiDemos
  // https://android.googlesource.com/platform/development/+/refs/heads/master/samples/ApiDemos/src/com/example/android/apis/graphics/CubeMapActivity.java
  
  // Hue to RGB conversion in GLSL based on
  // https://github.com/tobspr/GLSL-Color-Spaces
  
  #include "SampleApplication.h"
  
  #include "common/debug.h"
  #include "torus.h"
  #include "util/Matrix.h"
  #include "util/shader_utils.h"
  
  #include <iostream>
  
  const float kDegreesPerSecond = 90.0f;
  const GLushort kHuesSize      = (kSize + 1) * (kSize + 1);
  
  class BufferStorageSample : public SampleApplication
  {
    public:
      BufferStorageSample(int argc, char **argv)
          : SampleApplication("GLES3.1 Buffer Storage", argc, argv, 3, 1)
      {}
  
      bool initialize() override
      {
          if (!IsGLExtensionEnabled("GL_EXT_buffer_storage"))
          {
              std::cout << "GL_EXT_buffer_storage not available." << std::endl;
              return false;
          }
  
          constexpr char kVS[] = R"(#version 300 es
  uniform mat4 mv;
  uniform mat4 mvp;
  
  in vec4 position;
  in vec3 normal;
  in float hue;
  
  out vec3 normal_view;
  out vec4 color;
  
  vec4 hue_to_rgba(float hue)
  {
      hue = mod(hue, 1.0);
      float r = abs(hue * 6.0 - 3.0) - 1.0;
      float g = 2.0 - abs(hue * 6.0 - 2.0);
      float b = 2.0 - abs(hue * 6.0 - 4.0);
      return vec4(r, g, b, 1.0);
  }
  
  void main()
  {
      normal_view = vec3(mv * vec4(normal, 0.0));
      color = hue_to_rgba(hue);
      gl_Position = mvp * position;
  })";
  
          constexpr char kFS[] = R"(#version 300 es
  precision mediump float;
  
  in vec3 normal_view;
  in vec4 color;
  
  out vec4 frag_color;
  
  void main()
  {
      frag_color = color * dot(vec3(0.0, 0.0, 1.0), normalize(normal_view));
  })";
  
          mProgram = CompileProgram(kVS, kFS);
          if (!mProgram)
          {
              return false;
          }
  
          mPositionLoc = glGetAttribLocation(mProgram, "position");
          mNormalLoc   = glGetAttribLocation(mProgram, "normal");
          mHueLoc      = glGetAttribLocation(mProgram, "hue");
  
          mMVPMatrixLoc = glGetUniformLocation(mProgram, "mvp");
          mMVMatrixLoc  = glGetUniformLocation(mProgram, "mv");
  
          glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
          glEnable(GL_DEPTH_TEST);
  
          generateTorus();
  
          float ratio = static_cast<float>(getWindow()->getWidth()) /
                        static_cast<float>(getWindow()->getHeight());
          mPerspectiveMatrix = Matrix4::frustum(-ratio, ratio, -1, 1, 1.0f, 20.0f);
          mTranslationMatrix = Matrix4::translate(angle::Vector3(0, 0, -5));
  
          glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
          glUseProgram(mProgram);
  
          glEnableVertexAttribArray(mPositionLoc);
          glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
          glVertexAttribPointer(mPositionLoc, 3, GL_FLOAT, false, 6 * sizeof(GLfloat), nullptr);
  
          glVertexAttribPointer(mNormalLoc, 3, GL_FLOAT, false, 6 * sizeof(GLfloat),
                                reinterpret_cast<const void *>(3 * sizeof(GLfloat)));
          glEnableVertexAttribArray(mNormalLoc);
  
          glBindBuffer(GL_ARRAY_BUFFER, mHueBuffer);
          glVertexAttribPointer(mHueLoc, 1, GL_FLOAT, false, sizeof(GLfloat), nullptr);
          glEnableVertexAttribArray(mHueLoc);
  
          glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
  
          return true;
      }
  
      void destroy() override
      {
          glBindBuffer(GL_ARRAY_BUFFER, mHueBuffer);
          glUnmapBuffer(GL_ARRAY_BUFFER);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
          glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
          glDisableVertexAttribArray(mPositionLoc);
          glDisableVertexAttribArray(mNormalLoc);
          glDisableVertexAttribArray(mHueLoc);
          glDeleteBuffers(1, &mHueBuffer);
          glDeleteBuffers(1, &mVertexBuffer);
          glDeleteBuffers(1, &mIndexBuffer);
          glDeleteProgram(mProgram);
      }
  
      void step(float dt, double totalTime) override
      {
          mAngle += kDegreesPerSecond * dt;
          updateHues(totalTime);
      }
  
      void draw() override
      {
          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
          Matrix4 modelMatrix = mTranslationMatrix * Matrix4::rotate(mAngle, mYUnitVec) *
                                Matrix4::rotate(mAngle * 0.25f, mXUnitVec);
  
          Matrix4 mvpMatrix = mPerspectiveMatrix * modelMatrix;
  
          glUniformMatrix4fv(mMVMatrixLoc, 1, GL_FALSE, modelMatrix.data);
          glUniformMatrix4fv(mMVPMatrixLoc, 1, GL_FALSE, mvpMatrix.data);
  
          glDrawElements(GL_TRIANGLES, mIndexCount, GL_UNSIGNED_SHORT, 0);
  
          ASSERT(static_cast<GLenum>(GL_NO_ERROR) == glGetError());
      }
  
      void updateHues(double time)
      {
          for (uint32_t i = 0; i < kHuesSize; i++)
          {
              mHueMapPtr[i] = static_cast<GLfloat>(i) / static_cast<GLfloat>(kHuesSize) +
                              static_cast<GLfloat>(time);
          }
  
          GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
          glClientWaitSync(sync, 0, 0);
          glDeleteSync(sync);
      }
  
      void generateTorus()
      {
          GenerateTorus(&mVertexBuffer, &mIndexBuffer, &mIndexCount);
  
          std::vector<GLfloat> hues(kHuesSize, 0.0f);
  
          glGenBuffers(1, &mHueBuffer);
          glBindBuffer(GL_ARRAY_BUFFER, mHueBuffer);
          glBufferStorageEXT(GL_ARRAY_BUFFER, kHuesSize * sizeof(GLfloat), hues.data(),
                             GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT_EXT | GL_MAP_COHERENT_BIT_EXT);
  
          mHueMapPtr = static_cast<float *>(
              glMapBufferRange(GL_ARRAY_BUFFER, 0, kHuesSize * sizeof(GLfloat),
                               GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT |
                                   GL_MAP_PERSISTENT_BIT_EXT | GL_MAP_COHERENT_BIT_EXT));
  
          ASSERT(mHueMapPtr != nullptr);
          ASSERT(static_cast<GLenum>(GL_NO_ERROR) == glGetError());
      }
  
    private:
      GLuint mProgram = 0;
  
      GLint mPositionLoc = 0;
      GLint mNormalLoc   = 0;
      GLint mHueLoc      = 0;
  
      GLuint mMVPMatrixLoc = 0;
      GLuint mMVMatrixLoc  = 0;
  
      GLuint mVertexBuffer = 0;
      GLuint mHueBuffer    = 0;
      GLuint mIndexBuffer  = 0;
      GLsizei mIndexCount  = 0;
  
      Matrix4 mPerspectiveMatrix;
      Matrix4 mTranslationMatrix;
  
      const angle::Vector3 mYUnitVec{0.0f, 1.0f, 0.0f};
      const angle::Vector3 mXUnitVec{1.0f, 0.0f, 0.0f};
  
      float *mHueMapPtr = nullptr;
  
      float mAngle = 0;
  };
  
  int main(int argc, char **argv)
  {
      BufferStorageSample app(argc, argv);
      return app.run();
  }
  

Download