fix

yorkie · yorkie · commit 8997825b7dff · 2025-11-05T21:51:22.000+08:00
diff --git a/src/common/command_buffers/gpu/backend_connection.cpp b/src/common/command_buffers/gpu/backend_connection.cpp
@@ -0,0 +1,20 @@
+#include <common/command_buffers/gpu/backend_connection.hpp>
+
+namespace commandbuffers::gpu
+{
+  BackendConnection::BackendConnection(GPUInstance *instance, GPUBackendType type)
+      : instance_(instance)
+      , type_(type)
+  {
+  }
+
+  GPUBackendType BackendConnection::type() const
+  {
+    return type_;
+  }
+
+  GPUInstance *BackendConnection::getInstance() const
+  {
+    return instance_;
+  }
+}
diff --git a/src/common/command_buffers/gpu/backend_connection.hpp b/src/common/command_buffers/gpu/backend_connection.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <vector>
+#include <common/utility.hpp>
+#include <common/non_movable.hpp>
+#include <common/command_buffers/gpu/gpu_base.hpp>
+#include <common/command_buffers/gpu/gpu_instance.hpp>
+#include <common/command_buffers/gpu/gpu_adapter.hpp>
+#include <common/command_buffers/gpu/gpu_physical_device.hpp>
+
+namespace commandbuffers::gpu
+{
+  struct RequestAdapterOptions
+  {
+    GPUFeatureLevel featureLevel = GPUFeatureLevel::kCore;
+    GPUPowerPreference powerPreference = GPUPowerPreference::Undefined;
+    bool forceFallbackAdapter = false;
+    GPUBackendType backendType = GPUBackendType::kUndefined;
+  };
+
+  class BackendConnection : public NonMovable
+  {
+  public:
+    BackendConnection(GPUInstance *instance, GPUBackendType type);
+    virtual ~BackendConnection() = default;
+
+    GPUBackendType type() const;
+    GPUInstance *getInstance() const;
+
+    virtual std::vector<Ref<GPUPhysicalDeviceBase>> discoverPhysicalDevices(const RequestAdapterOptions &) = 0;
+
+  private:
+    GPUInstance *instance_ = nullptr;
+    GPUBackendType type_;
+  };
+}
diff --git a/src/common/command_buffers/gpu/gpu_adapter.cpp b/src/common/command_buffers/gpu/gpu_adapter.cpp
@@ -70,7 +70,7 @@ namespace commandbuffers
                            rhs.maxComputeWorkgroupsPerDimension);
   }
 
-  GPUAdapterBase::GPUAdapterBase(shared_ptr<GPUInstanceBase> instance,
+  GPUAdapterBase::GPUAdapterBase(shared_ptr<GPUInstance> instance,
                                  shared_ptr<GPUPhysicalDeviceBase> physicalDevice,
                                  GPUFeatureLevel level,
                                  GPUPowerPreference powerPreference)
diff --git a/src/common/command_buffers/gpu/gpu_adapter.hpp b/src/common/command_buffers/gpu/gpu_adapter.hpp
@@ -9,7 +9,7 @@
 
 namespace commandbuffers
 {
-  class GPUInstanceBase;
+  class GPUInstance;
   class GPUPhysicalDeviceBase;
   struct GPUDeviceDescriptor;
 
@@ -47,12 +47,12 @@ namespace commandbuffers
   class GPUAdapterBase : ErrorMonad
   {
   public:
-    GPUAdapterBase(std::shared_ptr<GPUInstanceBase> instance,
+    GPUAdapterBase(std::shared_ptr<GPUInstance> instance,
                    std::shared_ptr<GPUPhysicalDeviceBase> physicalDevice,
                    GPUFeatureLevel level,
                    GPUPowerPreference powerPreference);
 
-    GPUInstanceBase *instance() const;
+    GPUInstance *instance() const;
     const GPUAdapterInfo &info() const;
     bool hasFeature(GPUFeatureName) const;
     void requestDevice(const GPUDeviceDescriptor *descriptor,
@@ -66,7 +66,7 @@ namespace commandbuffers
     const std::string &name() const;
 
   private:
-    std::shared_ptr<GPUInstanceBase> instance_;
+    std::shared_ptr<GPUInstance> instance_;
     std::shared_ptr<GPUPhysicalDeviceBase> physical_device_;
     GPUFeatureLevel feature_level_;
     GPUPowerPreference power_preference_;
diff --git a/src/common/command_buffers/gpu/gpu_base.cpp b/src/common/command_buffers/gpu/gpu_base.cpp
@@ -88,7 +88,7 @@ namespace commandbuffers
   {
   }
 
-  GPUInstanceBase *GPUObject::instance() const
+  GPUInstance *GPUObject::instance() const
   {
     return device_->getInstance();
   }
diff --git a/src/common/command_buffers/gpu/gpu_base.hpp b/src/common/command_buffers/gpu/gpu_base.hpp
@@ -718,8 +718,8 @@ namespace commandbuffers
     static constexpr uint64_t kInitialized = 0b0;
   };
 
+  class GPUInstance;
   class GPUDeviceBase;
-  class GPUInstanceBase;
 
   class GPUObject : public ErrorMonad
   {
@@ -728,7 +728,7 @@ namespace commandbuffers
     GPUObject(std::shared_ptr<GPUDeviceBase> device, ErrorTag tag);
     GPUObject(std::shared_ptr<GPUDeviceBase> device, DelayedInitializationTag tag);
 
-    GPUInstanceBase *instance() const;
+    GPUInstance *instance() const;
     std::shared_ptr<GPUDeviceBase> device() const;
 
   private:
diff --git a/src/common/command_buffers/gpu/gpu_device.hpp b/src/common/command_buffers/gpu/gpu_device.hpp
@@ -38,7 +38,7 @@ namespace commandbuffers
 
     bool validateHandle(const GPUHandle &handle) const;
 
-    GPUInstanceBase *getInstance() const;
+    GPUInstance *getInstance() const;
     GPUAdapterBase *getAdapter() const;
     GPUPhysicalDeviceBase *getPhysicalDevice() const;
 
diff --git a/src/common/command_buffers/gpu/gpu_instance.cpp b/src/common/command_buffers/gpu/gpu_instance.cpp
@@ -1,40 +1,42 @@
 #include <common/command_buffers/gpu/gpu_instance.hpp>
+#include <common/command_buffers/gpu/backend_connection.hpp>
 
 using namespace std;
 
 namespace commandbuffers
 {
-  unique_ptr<GPUInstanceBase, GPUInstanceBase::Deleter> GPUInstanceBase::Create(const GPUInstanceDescriptor *descriptor)
+  Ref<GPUInstance> GPUInstance::Create(const GPUInstanceDescriptor *descriptor)
   {
     static constexpr GPUInstanceDescriptor kDefaultDesc = {};
     if (descriptor == nullptr)
     {
       descriptor = &kDefaultDesc;
     }
 
-    auto instance = unique_ptr<GPUInstanceBase, Deleter>(new GPUInstanceBase());
+    auto instance = Ref<GPUInstance>(new GPUInstance(), [](GPUInstance *ptr)
+                                     { delete ptr; });
     instance->initialize(*descriptor);
     return instance;
   }
 
-  void GPUInstanceBase::addDevice(shared_ptr<GPUDeviceBase>)
+  void GPUInstance::addDevice(shared_ptr<GPUDeviceBase>)
   {
   }
 
-  void GPUInstanceBase::removeDevice(shared_ptr<GPUDeviceBase>)
+  void GPUInstance::removeDevice(shared_ptr<GPUDeviceBase>)
   {
   }
 
-  bool GPUInstanceBase::hasFeature(GPUFeatureName feature) const
+  bool GPUInstance::hasFeature(GPUFeatureName feature) const
   {
     return instance_features_.find(feature) != instance_features_.end();
   }
 
-  GPUInstanceBase::GPUInstanceBase()
+  GPUInstance::GPUInstance()
   {
   }
 
-  void GPUInstanceBase::initialize(const GPUInstanceDescriptor &descriptor)
+  void GPUInstance::initialize(const GPUInstanceDescriptor &descriptor)
   {
   }
 }
diff --git a/src/common/command_buffers/gpu/gpu_instance.hpp b/src/common/command_buffers/gpu/gpu_instance.hpp
@@ -3,47 +3,50 @@
 #include <memory>
 #include <vector>
 #include <unordered_set>
+#include <common/utility.hpp>
 #include <common/command_buffers/gpu/gpu_adapter.hpp>
 #include <common/command_buffers/gpu/gpu_device.hpp>
 
 namespace commandbuffers
 {
+  namespace gpu
+  {
+    class BackendConnection;
+  }
+
   struct GPUInstanceDescriptor
   {
     size_t requiredFeatureCount = 0;
     GPUFeatureName const *requiredFeatures = nullptr;
     GPUSupportedLimits *requiredLimits = nullptr;
   };
 
-  class GPUInstanceBase
+  class GPUInstance final
   {
-  private:
-    // Custom deleter for `unique_ptr<GPUInstanceBase>`
-    struct Deleter
-    {
-      void operator()(GPUInstanceBase *ptr)
-      {
-        delete ptr;
-      }
-    };
-
   public:
-    static std::unique_ptr<GPUInstanceBase, Deleter> Create(const GPUInstanceDescriptor *descriptor = nullptr);
+    static Ref<GPUInstance> Create(const GPUInstanceDescriptor *descriptor = nullptr);
+
+    void registerBackend(gpu::BackendConnection *backend);
 
-    void addDevice(std::shared_ptr<GPUDeviceBase>);
-    void removeDevice(std::shared_ptr<GPUDeviceBase>);
+    void addDevice(Ref<GPUDeviceBase>);
+    void removeDevice(Ref<GPUDeviceBase>);
 
     bool hasFeature(GPUFeatureName feature) const;
 
   private:
-    explicit GPUInstanceBase();
-    virtual ~GPUInstanceBase() = default;
+    explicit GPUInstance();
+    virtual ~GPUInstance() = default;
 
     void initialize(const GPUInstanceDescriptor &descriptor);
-    std::shared_ptr<GPUAdapterBase> createAdapter();
+    Ref<GPUAdapterBase> createAdapter(Ref<GPUPhysicalDeviceBase> physicalDevice,
+                                      GPUFeatureLevel featureLevel,
+                                      GPUPowerPreference powerPreference);
+
+    gpu::BackendConnection *getBackendConnection() const;
 
   private:
     std::unordered_set<GPUFeatureName> instance_features_;
     std::vector<std::shared_ptr<GPUDeviceBase>> devices_list_;
+    Ref<gpu::BackendConnection> backend_ = nullptr;
   };
 }
diff --git a/src/common/command_buffers/gpu/gpu_physical_device.hpp b/src/common/command_buffers/gpu/gpu_physical_device.hpp
@@ -37,8 +37,8 @@ namespace commandbuffers
 
   private:
     virtual std::unique_ptr<GPUDeviceBase> createDeviceImpl(std::shared_ptr<GPUAdapterBase> adapter,
-                                                            GPUDeviceDescriptor &descriptor);
-    virtual void initializeImpl();
+                                                            GPUDeviceDescriptor &descriptor) = 0;
+    virtual void initializeImpl() = 0;
     virtual void initializeSupportedFeaturesImpl() = 0;
     virtual void initializeVendorArchitectureImpl();
 
diff --git a/src/common/utility.hpp b/src/common/utility.hpp
@@ -33,6 +33,9 @@ public:                                      \
 private:                                     \
   void *operator new(size_t) = delete
 
+template <typename T>
+using Ref = std::shared_ptr<T>;
+
 /**
  * Shared reference is a template class that holds the shared pointer of a type.
  *
diff --git a/src/renderer/gles/gpu_backend_impl.cpp b/src/renderer/gles/gpu_backend_impl.cpp
@@ -0,0 +1,23 @@
+#include <renderer/gles/gpu_backend_impl.hpp>
+
+using namespace std;
+using namespace commandbuffers;
+
+namespace gles
+{
+  GPUBackend::GPUBackend(GPUInstance *instance, GPUBackendType type)
+      : BackendConnection(instance, type)
+  {
+  }
+
+  vector<Ref<GPUPhysicalDeviceBase>> GPUBackend::discoverPhysicalDevices(const gpu::RequestAdapterOptions &options)
+  {
+    return {};
+  }
+
+  gpu::BackendConnection *Connect(GPUInstance *instance, GPUBackendType type)
+  {
+    assert(type == GPUBackendType::kOpenGL || type == GPUBackendType::kOpenGLES);
+    return new GPUBackend(instance, type);
+  }
+}
diff --git a/src/renderer/gles/gpu_backend_impl.hpp b/src/renderer/gles/gpu_backend_impl.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <common/utility.hpp>
+#include <common/command_buffers/gpu/gpu_instance.hpp>
+#include <common/command_buffers/gpu/backend_connection.hpp>
+
+namespace gles
+{
+  class GPUBackend final : public commandbuffers::gpu::BackendConnection
+  {
+  public:
+    GPUBackend(commandbuffers::GPUInstance *instance, commandbuffers::GPUBackendType type);
+
+    std::vector<Ref<commandbuffers::GPUPhysicalDeviceBase>> discoverPhysicalDevices(
+      const commandbuffers::gpu::RequestAdapterOptions &options) override;
+  };
+}
diff --git a/src/renderer/gles/gpu_physical_device_impl.cpp b/src/renderer/gles/gpu_physical_device_impl.cpp
@@ -0,0 +1,27 @@
+#include <renderer/gles/gpu_physical_device_impl.hpp>
+
+using namespace std;
+using namespace commandbuffers;
+
+namespace gles
+{
+  bool GPUPhysicalDeviceImpl::supportsExternalImages() const
+  {
+    return false;
+  }
+
+  unique_ptr<GPUDeviceBase> GPUPhysicalDeviceImpl::createDeviceImpl(shared_ptr<GPUAdapterBase> adapter,
+                                                                    GPUDeviceDescriptor &descriptor)
+  {
+    return nullptr;
+  }
+
+  void GPUPhysicalDeviceImpl::initializeImpl()
+  {
+  }
+
+  void GPUPhysicalDeviceImpl::initializeSupportedFeaturesImpl()
+  {
+  }
+
+}
diff --git a/src/renderer/gles/gpu_physical_device_impl.hpp b/src/renderer/gles/gpu_physical_device_impl.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <common/command_buffers/gpu/gpu_physical_device.hpp>
+#include <common/command_buffers/gpu/gpu_adapter.hpp>
+
+namespace gles
+{
+  class GPUPhysicalDeviceImpl final : public commandbuffers::GPUPhysicalDeviceBase
+  {
+  public:
+    bool supportsExternalImages() const override;
+
+  private:
+    std::unique_ptr<GPUDeviceBase> createDeviceImpl(std::shared_ptr<GPUAdapterBase> adapter,
+                                                    GPUDeviceDescriptor &descriptor) override;
+    void initializeImpl() override;
+    void initializeSupportedFeaturesImpl() override;
+  };
+}
diff --git a/src/renderer/render_api.cpp b/src/renderer/render_api.cpp
diff --git a/src/renderer/render_api.hpp b/src/renderer/render_api.hpp
diff --git a/src/renderer/render_api_opengles.cpp b/src/renderer/render_api_opengles.cpp

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ namespace commandbuffers`
`70`	`70`	`rhs.maxComputeWorkgroupsPerDimension);`
`71`	`71`	`}`
`72`	`72`
`73`		`- GPUAdapterBase::GPUAdapterBase(shared_ptr<GPUInstanceBase> instance,`
	`73`	`+ GPUAdapterBase::GPUAdapterBase(shared_ptr<GPUInstance> instance,`
`74`	`74`	`shared_ptr<GPUPhysicalDeviceBase> physicalDevice,`
`75`	`75`	`GPUFeatureLevel level,`
`76`	`76`	`GPUPowerPreference powerPreference)`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ namespace commandbuffers`
`88`	`88`	`{`
`89`	`89`	`}`
`90`	`90`
`91`		`- GPUInstanceBase *GPUObject::instance() const`
	`91`	`+ GPUInstance *GPUObject::instance() const`
`92`	`92`	`{`
`93`	`93`	`return device_->getInstance();`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,40 +1,42 @@`
`1`	`1`	`#include <common/command_buffers/gpu/gpu_instance.hpp>`
	`2`	`+#include <common/command_buffers/gpu/backend_connection.hpp>`
`2`	`3`
`3`	`4`	`using namespace std;`
`4`	`5`
`5`	`6`	`namespace commandbuffers`
`6`	`7`	`{`
`7`		`- unique_ptr<GPUInstanceBase, GPUInstanceBase::Deleter> GPUInstanceBase::Create(const GPUInstanceDescriptor *descriptor)`
	`8`	`+ Ref<GPUInstance> GPUInstance::Create(const GPUInstanceDescriptor *descriptor)`
`8`	`9`	`{`
`9`	`10`	`static constexpr GPUInstanceDescriptor kDefaultDesc = {};`
`10`	`11`	`if (descriptor == nullptr)`
`11`	`12`	`{`
`12`	`13`	`descriptor = &kDefaultDesc;`
`13`	`14`	`}`
`14`	`15`
`15`		`- auto instance = unique_ptr<GPUInstanceBase, Deleter>(new GPUInstanceBase());`
	`16`	`+ auto instance = Ref<GPUInstance>(new GPUInstance(), [](GPUInstance *ptr)`
	`17`	`+ { delete ptr; });`
`16`	`18`	`instance->initialize(*descriptor);`
`17`	`19`	`return instance;`
`18`	`20`	`}`
`19`	`21`
`20`		`- void GPUInstanceBase::addDevice(shared_ptr<GPUDeviceBase>)`
	`22`	`+ void GPUInstance::addDevice(shared_ptr<GPUDeviceBase>)`
`21`	`23`	`{`
`22`	`24`	`}`
`23`	`25`
`24`		`- void GPUInstanceBase::removeDevice(shared_ptr<GPUDeviceBase>)`
	`26`	`+ void GPUInstance::removeDevice(shared_ptr<GPUDeviceBase>)`
`25`	`27`	`{`
`26`	`28`	`}`
`27`	`29`
`28`		`- bool GPUInstanceBase::hasFeature(GPUFeatureName feature) const`
	`30`	`+ bool GPUInstance::hasFeature(GPUFeatureName feature) const`
`29`	`31`	`{`
`30`	`32`	`return instance_features_.find(feature) != instance_features_.end();`
`31`	`33`	`}`
`32`	`34`
`33`		`- GPUInstanceBase::GPUInstanceBase()`
	`35`	`+ GPUInstance::GPUInstance()`
`34`	`36`	`{`
`35`	`37`	`}`
`36`	`38`
`37`		`- void GPUInstanceBase::initialize(const GPUInstanceDescriptor &descriptor)`
	`39`	`+ void GPUInstance::initialize(const GPUInstanceDescriptor &descriptor)`
`38`	`40`	`{`
`39`	`41`	`}`
`40`	`42`	`}`