Vulkan/projects/utils/uvkuPhysicalDevice.pas

unit uvkuPhysicalDevice;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils,
  Vulkan;

type
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TVkQueueFamilyPropertiesArr       = array of TVkQueueFamilyProperties;
  TVkSparseImageFormatPropertiesArr = array of TVkSparseImageFormatProperties;
  TvkuPhysicalDevice = class(TObject)
  private
    fHandle: VkPhysicalDevice;
    function GetQueueFamilyProperties(const aIndex: Integer): TVkQueueFamilyProperties;
    function GetQueueFamilyPropertyCount: Integer;
  public
    function GetFeatures: TVkPhysicalDeviceFeatures;
    function GetProperties: TVkPhysicalDeviceProperties;
    function GetMemoryProperties: TVkPhysicalDeviceMemoryProperties;
    function GetQueueFamilyProperties: TVkQueueFamilyPropertiesArr;
    function GetFormatProperties(const aFormat: TVkFormat): TVkFormatProperties;
    function GetImageFormatProperties(
      const aFormat: TVkFormat;
      const aImageType: TVkImageType;
      const aTiling: TVkImageTiling;
      const aUsage: VkImageUsageFlags;
      const aFlags: VkImageCreateFlags): TVkImageFormatProperties;
    function GetSparseImageFormatProperties(
      const aFormat: TVkFormat;
      const aImageType: TVkImageType;
      const aSamples: TVkSampleCountFlagBits;
      const aUsage: VkImageUsageFlags;
      const aTiling: TVkImageTiling): TVkSparseImageFormatPropertiesArr;
  public
    property Handle:              VkPhysicalDevice                  read fHandle;
    property Features:            TVkPhysicalDeviceFeatures         read GetFeatures;
    property Properties:          TVkPhysicalDeviceProperties       read GetProperties;
    property MemoryProperties:    TVkPhysicalDeviceMemoryProperties read GetMemoryProperties;

    property QueueFamilyPropertyCount: Integer read GetQueueFamilyPropertyCount;
    property QueueFamilyProperties[const aIndex: Integer]: TVkQueueFamilyProperties read GetQueueFamilyProperties;

    property FormatProperties[const aFormat: TVkFormat]: TVkFormatProperties  read GetFormatProperties;

    constructor Create(const aHandle: VkPhysicalDevice);
  end;

implementation

uses
  uvkuUtils;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TvkuPhysicalDevice/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetQueueFamilyProperties(const aIndex: Integer): TVkQueueFamilyProperties;
var arr: TVkQueueFamilyPropertiesArr;
begin
  arr := GetQueueFamilyProperties();
  if (aIndex < Low(arr)) or (aIndex > High(arr)) then
    raise TvkuException.CreateFmt('index (%) out of range (%d : %d)', [aIndex, Low(arr), High(arr)]);
  result := arr[aIndex];
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetQueueFamilyPropertyCount: Integer;
begin
  result := Length(GetQueueFamilyProperties);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetFeatures: TVkPhysicalDeviceFeatures;
begin
  vkGetPhysicalDeviceFeatures(fHandle, @result);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetProperties: TVkPhysicalDeviceProperties;
begin
  vkGetPhysicalDeviceProperties(fHandle, @result);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetMemoryProperties: TVkPhysicalDeviceMemoryProperties;
begin
  vkGetPhysicalDeviceMemoryProperties(fHandle, @result);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetQueueFamilyProperties: TVkQueueFamilyPropertiesArr;
var c: VkUint32;
begin
  vkGetPhysicalDeviceQueueFamilyProperties(fHandle, @c, nil);
  SetLength(result, c);
  vkGetPhysicalDeviceQueueFamilyProperties(fHandle, @c, @result[0]);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetFormatProperties(const aFormat: TVkFormat): TVkFormatProperties;
begin
  vkGetPhysicalDeviceFormatProperties(fHandle, aFormat, @result);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetImageFormatProperties(const aFormat: TVkFormat; const aImageType: TVkImageType;
  const aTiling: TVkImageTiling; const aUsage: VkImageUsageFlags; const aFlags: VkImageCreateFlags): TVkImageFormatProperties;
var err: TVkResult;
begin
  err := vkGetPhysicalDeviceImageFormatProperties(fHandle, aFormat, aImageType, aTiling, aUsage, aFlags, @result);
  if (err < VK_SUCCESS) then
    raise TvkuErrorException.Create('unable to get physical device image format properties', err);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TvkuPhysicalDevice.GetSparseImageFormatProperties(const aFormat: TVkFormat; const aImageType: TVkImageType;
  const aSamples: TVkSampleCountFlagBits; const aUsage: VkImageUsageFlags; const aTiling: TVkImageTiling): TVkSparseImageFormatPropertiesArr;
var c: VkUint32;
begin
  vkGetPhysicalDeviceSparseImageFormatProperties(fHandle, aFormat, aImageType, aSamples, aUsage, aTiling, @c, nil);
  SetLength(result, c);
  vkGetPhysicalDeviceSparseImageFormatProperties(fHandle, aFormat, aImageType, aSamples, aUsage, aTiling, @c, @result[0]);
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TvkuPhysicalDevice.Create(const aHandle: VkPhysicalDevice);
begin
  if not Assigned(aHandle) then
    raise TvkuException.Create('invalid physical device handle');
  inherited Create;
  fHandle := aHandle;
end;

end.