Python GPU: New 'platform' module

This module exposes the platform utils defined in the GPU module in C.

This will be useful for porting existing code with `bgl` to `gpu`.

Reviewed By: fclem, brecht, campbellbarton

Maniphest Tasks: T80730

Part of D11147

1 files changed, 61 insertions, 12 deletions

diff --git a/source/blender/gpu/intern/gpu_platform.cc b/source/blender/gpu/intern/gpu_platform.cc
index 6b9878f2ba4..49dde473300 100644
--- a/source/blender/gpu/intern/gpu_platform.cc
+++ b/source/blender/gpu/intern/gpu_platform.cc
@@ -41,10 +41,10 @@ namespace blender::gpu {
 
 GPUPlatformGlobal GPG;
 
-void GPUPlatformGlobal::create_key(eGPUSupportLevel support_level,
-                                   const char *vendor,
-                                   const char *renderer,
-                                   const char *version)
+static char *create_key(eGPUSupportLevel support_level,
+                        const char *vendor,
+                        const char *renderer,
+                        const char *version)
 {
   DynStr *ds = BLI_dynstr_new();
   BLI_dynstr_appendf(ds, "{%s/%s/%s}=", vendor, renderer, version);
@@ -58,29 +58,56 @@ void GPUPlatformGlobal::create_key(eGPUSupportLevel support_level,
     BLI_dynstr_append(ds, "UNSUPPORTED");
   }
 
-  support_key = BLI_dynstr_get_cstring(ds);
+  char *support_key = BLI_dynstr_get_cstring(ds);
   BLI_dynstr_free(ds);
   BLI_str_replace_char(support_key, '\n', ' ');
   BLI_str_replace_char(support_key, '\r', ' ');
+  return support_key;
 }
 
-void GPUPlatformGlobal::create_gpu_name(const char *vendor,
-                                        const char *renderer,
-                                        const char *version)
+static char *create_gpu_name(const char *vendor, const char *renderer, const char *version)
 {
   DynStr *ds = BLI_dynstr_new();
   BLI_dynstr_appendf(ds, "%s %s %s", vendor, renderer, version);
 
-  gpu_name = BLI_dynstr_get_cstring(ds);
+  char *gpu_name = BLI_dynstr_get_cstring(ds);
   BLI_dynstr_free(ds);
   BLI_str_replace_char(gpu_name, '\n', ' ');
   BLI_str_replace_char(gpu_name, '\r', ' ');
+  return gpu_name;
+}
+
+void GPUPlatformGlobal::init(eGPUDeviceType gpu_device,
+                             eGPUOSType os_type,
+                             eGPUDriverType driver_type,
+                             eGPUSupportLevel gpu_support_level,
+                             const char *vendor_str,
+                             const char *renderer_str,
+                             const char *version_str)
+{
+  this->clear();
+
+  this->initialized = true;
+
+  this->device = gpu_device;
+  this->os = os_type;
+  this->driver = driver_type;
+  this->support_level = gpu_support_level;
+
+  this->vendor = BLI_strdup(vendor_str);
+  this->renderer = BLI_strdup(renderer_str);
+  this->version = BLI_strdup(version_str);
+  this->support_key = create_key(gpu_support_level, vendor_str, renderer_str, version_str);
+  this->gpu_name = create_gpu_name(vendor_str, renderer_str, version_str);
 }
 
 void GPUPlatformGlobal::clear()
 {
-  MEM_SAFE_FREE(GPG.support_key);
-  MEM_SAFE_FREE(GPG.gpu_name);
+  MEM_SAFE_FREE(vendor);
+  MEM_SAFE_FREE(renderer);
+  MEM_SAFE_FREE(version);
+  MEM_SAFE_FREE(support_key);
+  MEM_SAFE_FREE(gpu_name);
   initialized = false;
 }
 
@@ -96,22 +123,44 @@ using namespace blender::gpu;
 
 eGPUSupportLevel GPU_platform_support_level()
 {
+  BLI_assert(GPG.initialized);
   return GPG.support_level;
 }
 
-const char *GPU_platform_support_level_key()
+const char *GPU_platform_vendor(void)
+{
+  BLI_assert(GPG.initialized);
+  return GPG.vendor;
+}
+
+const char *GPU_platform_renderer(void)
+{
+  BLI_assert(GPG.initialized);
+  return GPG.renderer;
+}
+
+const char *GPU_platform_version(void)
+{
+  BLI_assert(GPG.initialized);
+  return GPG.version;
+}
+
+const char *GPU_platform_support_level_key(void)
 {
+  BLI_assert(GPG.initialized);
   return GPG.support_key;
 }
 
 const char *GPU_platform_gpu_name(void)
 {
+  BLI_assert(GPG.initialized);
   return GPG.gpu_name;
 }
 
 /* GPU Types */
 bool GPU_type_matches(eGPUDeviceType device, eGPUOSType os, eGPUDriverType driver)
 {
+  BLI_assert(GPG.initialized);
   return (GPG.device & device) && (GPG.os & os) && (GPG.driver & driver);
 }