fix(graphics): cache the shader's COMPILE_STATUS to avoid blocking call (#254)

Author: yorkie

src/client/graphics/webgl_context.cpp

@@ -378,20 +378,27 @@ namespace client_graphics
 
   int WebGLContext::getShaderParameter(shared_ptr<WebGLShader> shader, int pname)
   {
+    if (pname == WEBGL_SHADER_TYPE)
+      return static_cast<int>(shader->type);
+    if (pname == WEBGL_COMPILE_STATUS &&
+        shader->hasCompileStatus())
+      return static_cast<int>(shader->getCompileStatus());
+
+    // Otherwise, send a command buffer request and wait for the response.
     auto req = GetShaderParamCommandBufferRequest(shader->id, pname);
     sendCommandBufferRequest(req, true);
 
     auto resp = recvResponse<GetShaderParamCommandBufferResponse>(COMMAND_BUFFER_GET_SHADER_PARAM_RES, req);
-    if (resp != nullptr) [[likely]]
-    {
-      int value = resp->value;
-      delete resp;
-      return value;
-    }
+    assert(resp != nullptr && "Response should not be null");
+
+    shader->setShaderParameters(resp->deleteStatus,
+                                resp->compileStatus);
+    if (pname == WEBGL_DELETE_STATUS)
+      return static_cast<int>(resp->deleteStatus);
+    else if (pname == WEBGL_COMPILE_STATUS)
+      return static_cast<int>(resp->compileStatus);
     else
-    {
-      throw runtime_error("Failed to get shader parameter: timeout.");
-    }
+      throw runtime_error("Unsupported shader parameter: " + to_string(pname));
   }
 
   string WebGLContext::getShaderInfoLog(shared_ptr<WebGLShader> shader)

src/client/graphics/webgl_shader.hpp

@@ -16,15 +16,45 @@ namespace client_graphics
 
   class WebGLShader : public WebGLObject
   {
+    friend class WebGLContext;
+
   public:
     WebGLShader(WebGLShaderType type)
         : WebGLObject(WebGLObjectType::Shader)
         , type(type)
     {
     }
 
+    bool hasDeleteStatus() const
+    {
+      return delete_status_.has_value();
+    }
+    bool hasCompileStatus() const
+    {
+      return compile_status_.has_value();
+    }
+    bool getDeleteStatus()
+    {
+      return delete_status_.value_or(false);
+    }
+    bool getCompileStatus()
+    {
+      return compile_status_.value_or(false);
+    }
+
+  private:
+    void setShaderParameters(bool deleteStatus, bool compileStatus)
+    {
+      delete_status_ = deleteStatus;
+      compile_status_ = compileStatus;
+    }
+
   public:
     WebGLShaderType type;
     std::string source;
+
+  private:
+    std::optional<bool> delete_status_;
+    std::optional<bool> compile_status_;
   };
 }

src/common/command_buffers/details/shader.hpp

@@ -334,19 +334,20 @@ namespace commandbuffers
   {
   public:
     GetShaderParamCommandBufferResponse() = delete;
-    GetShaderParamCommandBufferResponse(GetShaderParamCommandBufferRequest *req, int32_t value)
+    GetShaderParamCommandBufferResponse(GetShaderParamCommandBufferRequest *req)
         : TrCommandBufferSimpleResponse(COMMAND_BUFFER_GET_SHADER_PARAM_RES, req)
-        , value(value)
     {
     }
     GetShaderParamCommandBufferResponse(const GetShaderParamCommandBufferResponse &that, bool clone)
         : TrCommandBufferSimpleResponse(that, clone)
-        , value(that.value)
+        , deleteStatus(that.deleteStatus)
+        , compileStatus(that.compileStatus)
     {
     }
 
   public:
-    int32_t value;
+    bool deleteStatus;
+    bool compileStatus;
   };
 
   class GetShaderInfoLogCommandBufferRequest final

src/renderer/render_api_opengles.cpp

@@ -850,12 +850,12 @@ class RHI_OpenGL : public TrRenderHardwareInterface
   {
     auto &glObjectManager = reqContentRenderer->getContextGL()->ObjectManagerRef();
     GLuint shader = glObjectManager.FindShader(req->shader);
-    GLint value;
-    glGetShaderiv(shader, req->pname, &value);
+    GetShaderParamCommandBufferResponse res(req);
+    glGetShaderiv(shader, GL_DELETE_STATUS, reinterpret_cast<GLint *>(&res.deleteStatus));
+    glGetShaderiv(shader, GL_COMPILE_STATUS, reinterpret_cast<GLint *>(&res.compileStatus));
 
-    GetShaderParamCommandBufferResponse res(req, value);
     if (TR_UNLIKELY(CheckError(req, reqContentRenderer) != GL_NO_ERROR || options.printsCall))
-      DEBUG(DEBUG_TAG, "[%d] GL::GetShaderParameter: %d", options.isDefaultQueue(), res.value);
+      PrintDebugInfo(req, nullptr, nullptr, options);
     reqContentRenderer->sendCommandBufferResponse(res);
   }
   TR_OPENGL_FUNC void OnGetShaderInfoLog(GetShaderInfoLogCommandBufferRequest *req,