Enhance GetInternalformatParameter handling and add support for GL_NUM_SAMPLE_COUNTS

Author: EndlessJour9527

src/client/graphics/webgl_context.cpp

@@ -1969,7 +1969,12 @@ namespace endor
       sendCommandBufferRequest(req, true);
       auto response = recvResponse<GetInternalformatParameterCommandBufferResponse>(
         COMMAND_BUFFER_GET_INTERNALFORMAT_PARAMETER_RES,
-        req.id);
+        req);
+
+      if (response == nullptr) [[unlikely]]
+      {
+        throw runtime_error("Failed to get internal format parameter: timeout.");
+      }
       return response->values;
     }
 

src/common/command_buffers/details/properties.hpp

@@ -250,8 +250,36 @@ namespace commandbuffers
     GetInternalformatParameterCommandBufferResponse(const GetInternalformatParameterCommandBufferResponse &that,
                                                     bool clone = false)
         : TrCommandBufferSimpleResponse(that, clone)
-        , values(that.values)
     {
+      if (clone)
+        values = that.values;
+    }
+
+  public:
+    TrCommandBufferMessage *serialize() override
+    {
+      auto message = new TrCommandBufferMessage(type, size, this);
+      if (values.size() > 0)
+      {
+        // Serialize the vector using addVecSegment
+        message->addVecSegment(values);
+      }
+      return message;
+    }
+
+    void deserialize(TrCommandBufferMessage &message) override
+    {
+      auto count = message.getSegmentCount();
+      if (count > 0)
+      {
+        auto segment = message.getSegment(0);
+        if (segment != nullptr && segment->size > 0)
+        {
+          size_t numValues = segment->size / sizeof(int);
+          values.resize(numValues);
+          std::memcpy(values.data(), segment->data, segment->size);
+        }
+      }
     }
 
   public:

src/common/command_buffers/macros.hpp

@@ -147,6 +147,7 @@
   XX(SAMPLER_PARAMETERF, SamplerParameterfCommandBufferRequest, "GL::SamplerParameterf")                                         \
   XX(GET_SAMPLER_PARAMETER, GetSamplerParameterCommandBufferRequest, "GL::GetSamplerParameter")                                  \
   XX(IS_SAMPLER, IsSamplerCommandBufferRequest, "GL::IsSampler")                                                                 \
+  XX(GET_INTERNALFORMAT_PARAMETER, GetInternalformatParameterCommandBufferRequest, "GL::GetInternalformatParameter")             \
   XX(XRFRAME_START, XRFrameStartCommandBufferRequest, "XR::FrameStart")                                                          \
   XX(XRFRAME_FLUSH, XRFrameFlushCommandBufferRequest, "XR::FrameFlush")                                                          \
   XX(XRFRAME_END, XRFrameEndCommandBufferRequest, "XR::FrameEnd")                                                                \
@@ -170,4 +171,5 @@
   XX(GET_FLOATV, GetFloatvCommandBufferResponse, "GL::GetFloatv")                                                \
   XX(GET_STRING, GetStringCommandBufferResponse, "GL::GetString")                                                \
   XX(GET_SHADER_PRECISION_FORMAT, GetShaderPrecisionFormatCommandBufferResponse, "GL::GetShaderPrecisionFormat") \
-  XX(GET_ERROR, GetErrorCommandBufferResponse, "GL::GetError")
+  XX(GET_ERROR, GetErrorCommandBufferResponse, "GL::GetError")                                                   \
+  XX(GET_INTERNALFORMAT_PARAMETER, GetInternalformatParameterCommandBufferResponse, "GL::GetInternalformatParameter")

src/common/command_buffers/webgl_constants.hpp

@@ -342,6 +342,8 @@ const int WEBGL_POLYGON_OFFSET_FACTOR = 0x8038;
 const int WEBGL_TEXTURE_BINDING_2D = 0x8069;
 const int WEBGL_SAMPLE_BUFFERS = 0x80A8;
 const int WEBGL_SAMPLES = 0x80A9;
+const int WEBGL_NUM_SAMPLE_COUNTS = 0x9380;
+const int WEBGL_SAMPLES_LEGACY = 0x862F;
 const int WEBGL_SAMPLE_COVERAGE_VALUE = 0x80AA;
 const int WEBGL_SAMPLE_COVERAGE_INVERT = 0x80AB;
 const int WEBGL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;

src/renderer/render_api_opengles.cpp

@@ -2677,38 +2677,66 @@ class RHI_OpenGL : public TrRenderHardwareInterface
   {
     std::vector<int> values;
 
-    // WebGL2 spec requires support for GL_SAMPLES and GL_NUM_SAMPLE_COUNTS
+    // support WEBGL_SAMPLES for now, throw for others
     if (req->pname == WEBGL_SAMPLES)
     {
-      // Query the actual supported sample counts from GL
+#ifdef ANDROID
       GLint numSampleCounts = 0;
       glGetInternalformativ(req->target, req->internalformat, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
-
-      if (numSampleCounts > 0)
+      GLenum error = glGetError();
+      if (error == GL_NO_ERROR && numSampleCounts > 0)
       {
         std::vector<GLint> samples(numSampleCounts);
         glGetInternalformativ(req->target, req->internalformat, GL_SAMPLES, numSampleCounts, samples.data());
-
-        // Convert to int vector and sort in descending order (WebGL2 spec requirement)
-        for (GLint sample : samples)
+        error = glGetError();
+        if (error == GL_NO_ERROR)
         {
-          values.push_back(static_cast<int>(sample));
+          for (GLint sample : samples)
+          {
+            if (sample > 0)
+              values.push_back(static_cast<int>(sample));
+          }
+          std::sort(values.begin(), values.end(), std::greater<int>());
         }
-        std::sort(values.begin(), values.end(), std::greater<int>());
       }
-      else
+      if (values.empty())
       {
-        // Fallback if query fails - return default sample counts
-        values = {4, 2, 1};
+        values = {4, 2};
       }
-    }
-    else if (req->pname == 0x862F) // GL_NUM_SAMPLE_COUNTS
-    {
+#else
       GLint numSampleCounts = 0;
       glGetInternalformativ(req->target, req->internalformat, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
-      values.push_back(static_cast<int>(numSampleCounts));
+      GLenum error = glGetError();
+      if (error == GL_NO_ERROR && numSampleCounts > 0)
+      {
+        std::vector<GLint> samples(numSampleCounts);
+        glGetInternalformativ(req->target, req->internalformat, GL_SAMPLES, numSampleCounts, samples.data());
+        error = glGetError();
+        DEBUG(DEBUG_TAG, "[GetInternalformatParameter] GL_SAMPLES query: error=0x%x", error);
+        if (error == GL_NO_ERROR)
+        {
+          for (GLint sample : samples)
+          {
+            if (sample > 0)
+              values.push_back(static_cast<int>(sample));
+          }
+          std::sort(values.begin(), values.end(), std::greater<int>());
+        }
+      }
+      if (values.empty())
+      {
+        DEBUG(DEBUG_TAG, "[GetInternalformatParameter] Using fallback values {4, 2}");
+        values = {4, 2};
+      }
+#endif
+    }
+    else
+    {
+      // Not implemented for other pnames
+      DEBUG(LOG_TAG_ERROR,
+            "[GetInternalformatParameter] pname 0x%x is not supported.",
+            req->pname);
     }
-    // For other pnames, return empty array (will be converted to null in binding)
 
     GetInternalformatParameterCommandBufferResponse res(req, values);
     if (TR_UNLIKELY(CheckError(req, reqContentRenderer) != GL_NO_ERROR || options.printsCall))