Factory.cpp

#include "Factory.h"
 
#ifdef COGS_DIRECT3D12
#include "Direct3D12/GraphicsDeviceD3D12.h"
#endif
 
#ifdef COGS_DIRECT3D11
#include "Direct3D11/GraphicsDeviceD3D11.h"
#endif
 
#ifdef COGS_OPENGL20
#include "OpenGL20/GraphicsDeviceGL20.h"
#endif
 
#ifdef COGS_OPENGLES30
#include "OpenGLES30/GraphicsDeviceGLES30.h"
#endif
 
#ifdef COGS_VULKAN
#include "Vulkan/GraphicsDeviceVK.h"
#endif
 
#ifdef COGS_WEBGPU
#include "WebGPU/GraphicsDeviceWebGPU.h"
#endif
 
#ifdef COGS_NULL
#include "Null/GraphicsDeviceNull.h"
#endif
 
#include "Foundation/Collections/SmallVector.h"
 
namespace
{
  using namespace Cogs;
 
  struct DeviceInfo
  {
    IGraphicsDevice * device;
    RenderingAllocatorInfo allocatorInfo;
  };
 
  Collections::SmallVector<DeviceInfo, 16> devices;
}
 
Cogs::IGraphicsDevice * Cogs::Factory::createDevice(RenderingAllocatorInfo * allocatorInfo)
{
#ifdef COGS_DIRECT3D11
  return createDevice(GraphicsDeviceType::Direct3D11, allocatorInfo);
#elif COGS_OPENGL20
  return createDevice(GraphicsDeviceType::OpenGL20, allocatorInfo);
#elif COGS_OPENGLES30
  return createDevice(GraphicsDeviceType::OpenGLES30, allocatorInfo);
#elif COGS_DIRECT3D12
  return createDevice(GraphicsDeviceType::Direct3D12, allocatorInfo);
#elif COGS_VULKAN
  return createDevice(GraphicsDeviceType::Vulkan, allocatorInfo);
#elif COGS_WEBGPU
  return createDevice(GraphicsDeviceType::WebGPU, allocatorInfo);
#elif COGS_NULL
  return createDevice(GraphicsDeviceType::Null, allocatorInfo);
#else
  return nullptr;
#endif
}
 
Cogs::IGraphicsDevice * Cogs::Factory::createDevice(const StringView& name)
{
  if (name == "Direct3D12" || name == "DirectX12") {
    return createDevice(GraphicsDeviceType::Direct3D12);
  } if (name == "Direct3D11" || name == "DirectX11") {
    return createDevice(GraphicsDeviceType::Direct3D11);
  } else if (name == "OpenGL20" || name == "OpenGL") {
    return createDevice(GraphicsDeviceType::OpenGL20);
  } else if (name == "OpenGLES30") {
    return createDevice(GraphicsDeviceType::OpenGLES30);
  } else if (name == "Vulkan") {
    return createDevice(GraphicsDeviceType::Vulkan);
  } else if (name == "Dawn" || name == "WebGPU") {
    return createDevice(GraphicsDeviceType::WebGPU);
  } else if (name == "Null") {
    return createDevice(GraphicsDeviceType::Null);
  }
 
  return nullptr;
}
 
namespace
{
  using namespace Cogs;
 
  template<typename DeviceType>
  DeviceType * create(RenderingAllocatorInfo * allocatorInfo)
  {
    auto device = Memory::create<DeviceType>(allocatorInfo->baseAllocator, allocatorInfo);
 
    devices.push_back({ device, *allocatorInfo });
 
    return device;
  }
}
 
Cogs::IGraphicsDevice * Cogs::Factory::createDevice(const GraphicsDeviceType & type, RenderingAllocatorInfo * externalAllocatorInfo)
{
  RenderingAllocatorInfo defaultAllocatorInfo = {
    Memory::Allocator::defaultAllocator(),
    Memory::Allocator::defaultAllocator(),
  };
 
  auto allocatorInfo = externalAllocatorInfo ? externalAllocatorInfo : &defaultAllocatorInfo;
 
  switch (type) {
  case GraphicsDeviceType::Unknown:
  default:
    return createDevice(allocatorInfo);
#ifdef COGS_DIRECT3D12
  case GraphicsDeviceType::Direct3D12:
    return create<GraphicsDeviceD3D12>(allocatorInfo);
#endif
#ifdef COGS_DIRECT3D11
  case GraphicsDeviceType::Direct3D11:
    return create<GraphicsDeviceD3D11>(allocatorInfo);
#endif
#ifdef COGS_OPENGL20
  case GraphicsDeviceType::OpenGL20:
    return create<GraphicsDeviceGL20>(allocatorInfo);
#endif
#ifdef COGS_OPENGLES30
  case GraphicsDeviceType::OpenGLES30:
    return create<GraphicsDeviceGLES30>(allocatorInfo);
#endif
#ifdef COGS_VULKAN
  case GraphicsDeviceType::Vulkan:
    return create<GraphicsDeviceVK>(allocatorInfo);
#endif
#ifdef COGS_WEBGPU
  case GraphicsDeviceType::WebGPU:
    return create<GraphicsDeviceWebGPU>(allocatorInfo);
#endif
#ifdef COGS_NULL
  case GraphicsDeviceType::Null:
    return create<GraphicsDeviceNull>(allocatorInfo);
#endif
  }
}
 
void Cogs::Factory::releaseDevice(IGraphicsDevice * device)
{
  size_t index = 0;
  for (size_t i = 0; i < devices.size(); ++i) {
    if (devices[i].device == device) {
      index = i;
      break;
    }
  }
 
  size_t deviceSize = 0;
  switch (device->getType())
  {
#ifdef COGS_DIRECT3D12
  case GraphicsDeviceType::Direct3D12:
    deviceSize = sizeof(GraphicsDeviceD3D12);
    break;
#endif
#ifdef COGS_DIRECT3D11
  case GraphicsDeviceType::Direct3D11:
    deviceSize = sizeof(GraphicsDeviceD3D11);
    break;
#endif
#ifdef COGS_OPENGL20
  case GraphicsDeviceType::OpenGL20:
    deviceSize = sizeof(GraphicsDeviceGL20);
    break;
#endif
#ifdef COGS_OPENGLES30
  case GraphicsDeviceType::OpenGLES30:
    deviceSize = sizeof(GraphicsDeviceGLES30);
    break;
#endif
#ifdef COGS_VULKAN
  case GraphicsDeviceType::Vulkan:
    deviceSize = sizeof(GraphicsDeviceVK);
    break;
#endif
#ifdef COGS_WEBGPU
  case GraphicsDeviceType::WebGPU:
    deviceSize = sizeof(GraphicsDeviceWebGPU);
    break;
#endif
#ifdef COGS_NULL
  case GraphicsDeviceType::Null:
    deviceSize = sizeof(GraphicsDeviceNull);
    break;
#endif
  default:
    deviceSize = 0;
    break;
  }
 
  device->~IGraphicsDevice();
  devices[index].allocatorInfo.baseAllocator->deallocate(device, deviceSize);
  devices.erase(devices.begin() + index);
}