Add a way to retrieve the GL_RENDERER and GL_VENDOR strings

filament/backend/include/backend/DriverEnums.h

@@ -1312,6 +1312,13 @@ enum class Workaround : uint16_t {
 
 using StereoscopicType = backend::Platform::StereoscopicType;
 
+enum class BackendString : uint8_t {
+    // OpenGL backend only. Return the GL_VENDOR string.
+    VENDOR,
+    // OpenGL backend only. Return the GL_RENDERER string.
+    RENDERER
+};
+
 } // namespace filament::backend
 
 template<> struct utils::EnableBitMaskOperators<filament::backend::ShaderStageFlags>

filament/backend/include/private/backend/DriverAPI.inc

@@ -357,6 +357,7 @@ DECL_DRIVER_API_SYNCHRONOUS_N(void, setupExternalImage, void*, image)
 DECL_DRIVER_API_SYNCHRONOUS_N(backend::TimerQueryResult, getTimerQueryValue, backend::TimerQueryHandle, query, uint64_t*, elapsedTime)
 DECL_DRIVER_API_SYNCHRONOUS_N(bool, isWorkaroundNeeded, backend::Workaround, workaround)
 DECL_DRIVER_API_SYNCHRONOUS_0(backend::FeatureLevel, getFeatureLevel)
+DECL_DRIVER_API_SYNCHRONOUS_N(char const*, getString, backend::BackendString, stringName)
 
 /*
  * Updating driver objects

filament/backend/src/metal/MetalDriver.mm

@@ -1132,6 +1132,10 @@
     return FeatureLevel::FEATURE_LEVEL_2;
 }
 
+char const* MetalDriver::getString(backend::BackendString) {
+    return nullptr;
+}
+
 math::float2 MetalDriver::getClipSpaceParams() {
     // virtual and physical z-coordinate of clip-space is in [-w, 0]
     // Note: this is actually never used (see: main.vs), but it's a backend API so we implement it

filament/backend/src/noop/NoopDriver.cpp

@@ -14,9 +14,14 @@
  * limitations under the License.
  */
 
+#include <backend/DriverEnums.h>
+#include <backend/Handle.h>
+
 #include "noop/NoopDriver.h"
 #include "CommandStreamDispatcher.h"
 
+#include<stdint.h>
+
 namespace filament::backend {
 
 Driver* NoopDriver::create() {
@@ -217,6 +222,10 @@ FeatureLevel NoopDriver::getFeatureLevel() {
     return FeatureLevel::FEATURE_LEVEL_1;
 }
 
+char const* NoopDriver::getString(backend::BackendString) {
+    return nullptr;
+}
+
 math::float2 NoopDriver::getClipSpaceParams() {
     return math::float2{ 1.0f, 0.0f };
 }

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -2363,6 +2363,16 @@ FeatureLevel OpenGLDriver::getFeatureLevel() {
     return mContext.getFeatureLevel();
 }
 
+char const* OpenGLDriver::getString(BackendString stringName) {
+    switch (stringName) {
+    case BackendString::VENDOR:
+        return mContext.state.vendor;
+    case BackendString::RENDERER:
+        return mContext.state.renderer;
+    }
+    return nullptr;
+}
+
 math::float2 OpenGLDriver::getClipSpaceParams() {
     return mContext.ext.EXT_clip_control ?
            // z-coordinate of virtual and physical clip-space is in [-w, 0]

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -1089,6 +1089,10 @@ FeatureLevel VulkanDriver::getFeatureLevel() {
     return FeatureLevel::FEATURE_LEVEL_3;
 }
 
+char const* VulkanDriver::getString(backend::BackendString) {
+    return nullptr;
+}
+
 math::float2 VulkanDriver::getClipSpaceParams() {
     // virtual and physical z-coordinate of clip-space is in [-w, 0]
     // Note: this is actually never used (see: main.vs), but it's a backend API, so we implement it

filament/include/filament/Engine.h

@@ -638,6 +638,21 @@ class UTILS_PUBLIC Engine {
      */
     static void destroy(Engine* UTILS_NULLABLE engine);
 
+
+    /**
+     * This is only available with the OpenGL backend.
+     * @see getBackend
+     * @return GL_VENDOR string or nullptr if the backend is not OpenGL.
+     */
+    char const* UTILS_NULLABLE getVendorString() const noexcept;
+
+    /**
+     * This is only available with the OpenGL backend.
+     * @see getBackend
+     * @return GL_RENDERER string or nullptr if the backend is not OpenGL.
+     */
+    char const* UTILS_NULLABLE getRendererString() const noexcept;
+
     /**
      * Query the feature level supported by the selected backend.
      *

filament/src/Engine.cpp

@@ -76,6 +76,14 @@ void Engine::destroy(Engine** pEngine) {
     }
 }
 
+char const* Engine::getVendorString() const noexcept {
+    return downcast(this)->getVendorString();
+}
+
+char const* Engine::getRendererString() const noexcept {
+    return downcast(this)->getRendererString();
+}
+
 // -----------------------------------------------------------------------------------------------
 // Resource management
 // -----------------------------------------------------------------------------------------------

filament/src/details/Engine.h

@@ -61,6 +61,8 @@
 #include <filament/Texture.h>
 #include <filament/VertexBuffer.h>
 
+#include <backend/DriverEnums.h>
+
 #include <utils/Allocator.h>
 #include <utils/compiler.h>
 #include <utils/CountDownLatch.h>
@@ -114,12 +116,11 @@ class ResourceAllocator;
  */
 class FEngine : public Engine {
 public:
-
-    inline void* operator new(std::size_t const size) noexcept {
+    void* operator new(std::size_t const size) noexcept {
         return utils::aligned_alloc(size, alignof(FEngine));
     }
 
-    inline void operator delete(void* p) noexcept {
+    void operator delete(void* p) noexcept {
         utils::aligned_free(p);
     }
 
@@ -140,6 +141,14 @@ class FEngine : public Engine {
 
     ~FEngine() noexcept;
 
+    char const* getVendorString() const noexcept {
+        return getDriver().getString(backend::BackendString::VENDOR);
+    }
+
+    char const* getRendererString() const noexcept {
+        return getDriver().getString(backend::BackendString::RENDERER);
+    }
+
     backend::ShaderModel getShaderModel() const noexcept { return getDriver().getShaderModel(); }
 
     DriverApi& getDriverApi() noexcept {
@@ -489,7 +498,7 @@ class FEngine : public Engine {
     backend::Handle<backend::HwTexture> getOneTextureArray() const { return mDummyOneTextureArray; }
     backend::Handle<backend::HwTexture> getZeroTextureArray() const { return mDummyZeroTextureArray; }
 
-    static constexpr const size_t MiB = 1024u * 1024u;
+    static constexpr size_t MiB = 1024u * 1024u;
     size_t getMinCommandBufferSize() const noexcept { return mConfig.minCommandBufferSizeMB * MiB; }
     size_t getCommandBufferSize() const noexcept { return mConfig.commandBufferSizeMB * MiB; }
     size_t getPerFrameCommandsSize() const noexcept { return mConfig.perFrameCommandsSizeMB * MiB; }