private static bool IsSuitableDevice(Vk api, PhysicalDevice physicalDevice, SurfaceKHR surface)
{
int extensionMatches = 0;
uint propertiesCount;
api.EnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, &propertiesCount, null).ThrowOnError();
ExtensionProperties[] extensionProperties = new ExtensionProperties[propertiesCount];
fixed(ExtensionProperties *pExtensionProperties = extensionProperties)
{
api.EnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, &propertiesCount, pExtensionProperties).ThrowOnError();
for (int i = 0; i < propertiesCount; i++)
{
string extensionName = Marshal.PtrToStringAnsi((IntPtr)pExtensionProperties[i].ExtensionName);
if (RequiredExtensions.Contains(extensionName))
{
extensionMatches++;
}
}
}
return(extensionMatches == RequiredExtensions.Length && FindSuitableQueueFamily(api, physicalDevice, surface, out _) != InvalidIndex);
}
public static ExtensionProperties[] EnumerateInstanceExtensionProperties(string pLayerName)
{
unsafe {
uint pPropertyCount;
var result = Interop.NativeMethods.vkEnumerateInstanceExtensionProperties(pLayerName, &pPropertyCount, null);
if (result != Result.Success)
{
throw new ResultException(result);
}
if (pPropertyCount <= 0)
{
return(null);
}
var size = Marshal.SizeOf(typeof(Interop.ExtensionProperties));
var ptrpProperties = Marshal.AllocHGlobal((int)(size * pPropertyCount));
result = Interop.NativeMethods.vkEnumerateInstanceExtensionProperties(pLayerName, &pPropertyCount, (Interop.ExtensionProperties *)ptrpProperties);
if (result != Result.Success)
{
throw new ResultException(result);
}
if (pPropertyCount <= 0)
{
return(null);
}
var arr = new ExtensionProperties [pPropertyCount];
for (var i = 0; i < pPropertyCount; i++)
{
arr [i] = new ExtensionProperties(&((Interop.ExtensionProperties *)ptrpProperties) [i]);
}
return(arr);
}
}
public static Accessor FindPropertyByName <TEntity>(string propertyName)
{
var propertyToFind = propertyName;
var prefix = typeof(TEntity).Name;
if (propertyToFind.StartsWith(prefix))
{
propertyToFind = propertyToFind.Substring(prefix.Length);
}
//This is to handle the situation with address where we have properties that start with the type name.
//We won't find any properties for 1 on address when we are looking for address1 and then rip off the type name.
var property = TypeDescriptorCache.GetPropertyFor(typeof(TEntity), propertyToFind) ??
TypeDescriptorCache.GetPropertyFor(typeof(TEntity), propertyName);
if (property != null)
{
return(new SingleProperty(property));
}
if (ExtensionProperties.HasExtensionFor(typeof(TEntity)))
{
var extensionType = ExtensionProperties.ExtensionFor(typeof(TEntity));
var extensionProperty = TypeDescriptorCache.GetPropertyFor(extensionType, propertyToFind);
var extensionAccessorType = typeof(ExtensionPropertyAccessor <>).MakeGenericType(extensionType);
return((Accessor)Activator.CreateInstance(extensionAccessorType, extensionProperty));
}
return(null);
}
public static void EnumerateInstanceExtensions(Vk vk, out ExtensionProperties[] extensions)
{
uint extcount;
vk.EnumerateInstanceExtensionProperties((byte *)IntPtr.Zero, &extcount, null);
extensions = new ExtensionProperties[extcount];
vk.EnumerateInstanceExtensionProperties((byte *)IntPtr.Zero, &extcount, extensions);
}
public void EnumerateExtensionPropertiesForSingleLayer()
{
ExtensionProperties[] properties = Instance.EnumerateExtensionProperties(
InstanceLayer.LunarGStandardValidation);
Assert.NotEmpty(properties);
ExtensionProperties firstProperty = properties[0];
Assert.StartsWith(firstProperty.ExtensionName, properties[0].ToString());
}
public static Result EnumerateInstanceExtensionProperties(string pLayerName, out UInt32 PropertyCount, out ExtensionProperties Properties)
{
unsafe
{
fixed(UInt32 *ptrPropertyCount = &PropertyCount)
{
Properties = new ExtensionProperties();
return(Interop.NativeMethods.vkEnumerateInstanceExtensionProperties(pLayerName, ptrPropertyCount, (IntPtr)Properties.m));
}
}
}
public static void SetValueNoCallback(this DependencyObject obj, DependencyProperty property, object value)
{
ExtensionProperties.SetAreHandlersSuspended(obj, true);
try
{
obj.SetValue(property, value);
}
finally
{
ExtensionProperties.SetAreHandlersSuspended(obj, false);
}
}
private unsafe ReadOnlyCollection <ExtensionProperties> EnumerateDeviceExtensions()
{
VkExtensionProperties[] vkProps = _gd.GetDeviceExtensionProperties();
ExtensionProperties[] veldridProps = new ExtensionProperties[vkProps.Length];
for (int i = 0; i < vkProps.Length; i++)
{
VkExtensionProperties prop = vkProps[i];
veldridProps[i] = new ExtensionProperties(Util.GetString(prop.extensionName), prop.specVersion);
}
return(new ReadOnlyCollection <ExtensionProperties>(veldridProps));
}
public static string[] GetSupportedExtensions(Vk api, PhysicalDevice physicalDevice)
{
uint propertiesCount;
api.EnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, &propertiesCount, null).ThrowOnError();
ExtensionProperties[] extensionProperties = new ExtensionProperties[propertiesCount];
fixed(ExtensionProperties *pExtensionProperties = extensionProperties)
{
api.EnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, &propertiesCount, pExtensionProperties).ThrowOnError();
}
return(extensionProperties.Select(x => Marshal.PtrToStringAnsi((IntPtr)x.ExtensionName)).ToArray());
}
internal unsafe string[] GetSupportedExtensions()
{
uint propertiesCount;
Api.EnumerateDeviceExtensionProperties(InternalHandle, (byte *)null, &propertiesCount, null).ThrowOnError();
var extensionProperties = new ExtensionProperties[propertiesCount];
fixed(ExtensionProperties *pExtensionProperties = extensionProperties)
{
Api.EnumerateDeviceExtensionProperties(InternalHandle, (byte *)null, &propertiesCount, pExtensionProperties)
.ThrowOnError();
}
return(extensionProperties.Select(x => Marshal.PtrToStringAnsi((IntPtr)x.ExtensionName)).ToArray());
}
private static unsafe bool IsSuitableDevice(Vk api, PhysicalDevice physicalDevice, PhysicalDeviceProperties properties, SurfaceKHR surface,
out uint queueCount, out uint familyIndex)
{
queueCount = 0;
familyIndex = 0;
if (properties.DeviceType == PhysicalDeviceType.Cpu)
{
return(false);
}
var extensionMatches = 0;
uint propertiesCount;
api.EnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, &propertiesCount, null).ThrowOnError();
var extensionProperties = new ExtensionProperties[propertiesCount];
fixed(ExtensionProperties *pExtensionProperties = extensionProperties)
{
api.EnumerateDeviceExtensionProperties(
physicalDevice,
(byte *)null,
&propertiesCount,
pExtensionProperties).ThrowOnError();
for (var i = 0; i < propertiesCount; i++)
{
var extensionName = Marshal.PtrToStringAnsi((IntPtr)pExtensionProperties[i].ExtensionName);
if (VulkanInitialization.RequiredExtensions.Contains(extensionName))
{
extensionMatches++;
}
}
}
if (extensionMatches == VulkanInitialization.RequiredExtensions.Length)
{
familyIndex = FindSuitableQueueFamily(api, physicalDevice, surface, out queueCount);
return(familyIndex != uint.MaxValue);
}
return(false);
}
public static ExtensionProperties[] EnumerateInstanceExtensionProperties(string pLayerName = null)
{
Result result;
unsafe
{
UInt32 pPropertyCount;
result = Interop.NativeMethods.vkEnumerateInstanceExtensionProperties(pLayerName, &pPropertyCount, null);
if (result != Result.Success)
{
throw new ResultException(result);
}
if (pPropertyCount <= 0)
{
return(null);
}
int size = Marshal.SizeOf(typeof(Interop.ExtensionProperties));
var refpProperties = new NativeReference((int)(size * pPropertyCount));
var ptrpProperties = refpProperties.Handle;
result = Interop.NativeMethods.vkEnumerateInstanceExtensionProperties(pLayerName, &pPropertyCount, (Interop.ExtensionProperties *)ptrpProperties);
if (result != Result.Success)
{
throw new ResultException(result);
}
if (pPropertyCount <= 0)
{
return(null);
}
var arr = new ExtensionProperties[pPropertyCount];
for (int i = 0; i < pPropertyCount; i++)
{
arr[i] = new ExtensionProperties(new NativePointer(refpProperties, (IntPtr)(&((Interop.ExtensionProperties *)ptrpProperties)[i])));
}
return(arr);
}
}
public static unsafe ExtensionProperties[] GetInstanceExtensionProperties(string layerName = null)
{
var nativeString = layerName != null ? Marshal.StringToHGlobalAnsi(layerName) : IntPtr.Zero;
try
{
uint count = 0;
EnumerateInstanceExtensionProperties((byte*)nativeString, ref count, null);
var result = new ExtensionProperties[count];
if (count > 0)
{
fixed (ExtensionProperties* resultPointer = &result[0])
EnumerateInstanceExtensionProperties((byte*)nativeString, ref count, resultPointer);
}
return result;
}
finally
{
Marshal.FreeHGlobal(nativeString);
}
}
public unsafe ExtensionProperties[] GetDeviceExtensionProperties(string layerName = null)
{
var nativeString = layerName != null?Marshal.StringToHGlobalAnsi(layerName) : IntPtr.Zero;
try
{
uint count = 0;
EnumerateDeviceExtensionProperties((byte *)nativeString, ref count, null);
var result = new ExtensionProperties[count];
if (count > 0)
{
fixed(ExtensionProperties *resultPointer = &result[0])
EnumerateDeviceExtensionProperties((byte *)nativeString, ref count, resultPointer);
}
return(result);
}
finally
{
Marshal.FreeHGlobal(nativeString);
}
}
public string GetUserExtensionPropertyName()
{
return(ExtensionProperties.First(x => x.Name.EndsWith("_cidn", StringComparison.OrdinalIgnoreCase)).Name);
}
AppInstance AppCreateInstance(uint apiVersion)
{
ApplicationInfo appInfo = new ApplicationInfo
{
ApplicationName = ApplicationName,
ApplicationVersion = ApplicationVersion,
EngineName = EngineName,
EngineVersion = EnginveVersion,
ApiVersion = apiVersion,
};
InstanceCreateInfo createInfo = new InstanceCreateInfo
{
ApplicationInfo = appInfo,
EnabledLayerCount = 0,
EnabledExtensionCount = 0,
};
// Scan layers
List <LayerExtensionList> layers = new List <LayerExtensionList>();
LayerProperties[] layerProperties = Commands.EnumerateInstanceLayerProperties();
if (layerProperties != null)
{
foreach (LayerProperties layer in layerProperties)
{
LayerExtensionList layerExtList = new LayerExtensionList
{
LayerProperties = layer,
ExtensionProperties = Commands.EnumerateInstanceExtensionProperties(layer.LayerName),
};
if (layerExtList.ExtensionProperties == null)
{
layerExtList.ExtensionProperties = new ExtensionProperties[0];
}
layers.Add(layerExtList);
}
}
ExtensionProperties[] extensions = Commands.EnumerateInstanceExtensionProperties("");
if (extensions == null)
{
extensions = new ExtensionProperties[0];
}
foreach (string knownExtName in KnownExtensions)
{
bool extensionFound = false;
foreach (ExtensionProperties extention in extensions)
{
if (extention.ExtensionName == knownExtName)
{
extensionFound = true;
break;
}
}
if (!extensionFound)
{
throw new Exception("Cannot find extension: " + knownExtName);
}
}
createInfo.EnabledExtensionNames = KnownExtensions;
createInfo.EnabledExtensionCount = (uint)KnownExtensions.Length;
// TODO : Register debug callback
Instance instance = new Instance(createInfo);
return(new AppInstance
{
Instance = instance,
Layers = layers.ToArray(),
Extensions = extensions,
});
}
internal unsafe void EnumerateDeviceExtensionProperties(byte* layerName, ref uint propertyCount, ExtensionProperties* properties)
{
fixed (uint* __propertyCount__ = &propertyCount)
{
vkEnumerateDeviceExtensionProperties(this, layerName, __propertyCount__, properties).CheckError();
}
}
internal static unsafe void EnumerateInstanceExtensionProperties(byte* layerName, ref uint propertyCount, ExtensionProperties* properties)
{
fixed (uint* __propertyCount__ = &propertyCount)
{
vkEnumerateInstanceExtensionProperties(layerName, __propertyCount__, properties).CheckError();
}
}
internal static unsafe extern Result vkEnumerateInstanceExtensionProperties(byte* layerName, uint* propertyCount, ExtensionProperties* properties);
internal static unsafe extern Result vkEnumerateDeviceExtensionProperties(PhysicalDevice physicalDevice, byte* layerName, uint* propertyCount, ExtensionProperties* properties);
public string GetGroupExtensionPropertyName()
{
return(ExtensionProperties.First(x => x.Name.Contains("group")).Name);
}
/// <summary>
/// Returns a blank instance of the B2CUser with any extension properties required added to the
/// NonDeclaredProperties collection.
/// </summary>
/// <returns>An instance of B2CUser</returns>
public B2CUser GetBlankNewB2CUser()
{
var newUser = new B2CUser(ExtensionProperties.Where(x => !x.Name.Contains("group")).ToList());
return(newUser);
}
/// <summary>
/// Created a blank group with extension properties
/// </summary>
/// <returns>Group</returns>
public Group GetBlankGroup()
{
var newGroup = new Group(ExtensionProperties.Where(x => x.Name.Contains("group")).ToList());
return(newGroup);
}
public static bool AreHandlersSuspended(this DependencyObject obj)
{
return(ExtensionProperties.GetAreHandlersSuspended(obj));
}
private unsafe void Prepare()
{
// Create our API object for OpenXR.
Xr = XR.GetApi();
Extensions.Clear();
//Extensions.Add("XR_KHR_vulkan_enable2");
Extensions.Add("XR_KHR_vulkan_enable");
Extensions.Add("XR_EXT_hp_mixed_reality_controller");
Extensions.Add("XR_HTC_vive_cosmos_controller_interaction");
Extensions.Add("XR_MSFT_hand_interaction");
Extensions.Add("XR_EXT_samsung_odyssey_controller");
uint propCount = 0;
Xr.EnumerateInstanceExtensionProperties((byte *)null, 0, &propCount, null);
ExtensionProperties[] props = new ExtensionProperties[propCount];
for (int i = 0; i < props.Length; i++)
{
props[i].Type = StructureType.TypeExtensionProperties;
fixed(ExtensionProperties *pptr = &props[0])
Xr.EnumerateInstanceExtensionProperties((byte *)null, propCount, ref propCount, pptr);
List <string> AvailableExtensions = new List <string>();
for (int i = 0; i < props.Length; i++)
{
fixed(void *nptr = props[i].ExtensionName)
AvailableExtensions.Add(Marshal.PtrToStringAnsi(new System.IntPtr(nptr)));
}
for (int i = 0; i < Extensions.Count; i++)
{
if (AvailableExtensions.Contains(Extensions[i]) == false)
{
Extensions.RemoveAt(i);
i--;
}
}
InstanceCreateInfo instanceCreateInfo;
var appInfo = new ApplicationInfo()
{
ApiVersion = new Version64(1, 0, 9)
};
// We've got to marshal our strings and put them into global, immovable memory. To do that, we use
// SilkMarshal.
Span <byte> appName = new Span <byte>(appInfo.ApplicationName, 128);
Span <byte> engName = new Span <byte>(appInfo.EngineName, 128);
SilkMarshal.StringIntoSpan(System.AppDomain.CurrentDomain.FriendlyName, appName);
SilkMarshal.StringIntoSpan("FocusEngine", engName);
var requestedExtensions = SilkMarshal.StringArrayToPtr(Extensions);
instanceCreateInfo = new InstanceCreateInfo
(
applicationInfo: appInfo,
enabledExtensionCount: (uint)Extensions.Count,
enabledExtensionNames: (byte **)requestedExtensions
);
// Now we're ready to make our instance!
CheckResult(Xr.CreateInstance(in instanceCreateInfo, ref Instance), "CreateInstance");
// For our benefit, let's log some information about the instance we've just created.
// skip this, as it crashes on Oculus runtime and is not needed
/*InstanceProperties properties = new();
* CheckResult(Xr.GetInstanceProperties(Instance, ref properties), "GetInstanceProperties");
*
* var runtimeName = SilkMarshal.PtrToString((nint)properties.RuntimeName);
* var runtimeVersion = ((Version)(Version64)properties.RuntimeVersion).ToString(3);
*
* Console.WriteLine($"[INFO] Application: Using OpenXR Runtime \"{runtimeName}\" v{runtimeVersion}");*/
// We're creating a head-mounted-display (HMD, i.e. a VR headset) example, so we ask for a runtime which
// supports that form factor. The response we get is a ulong that is the System ID.
var getInfo = new SystemGetInfo(formFactor: FormFactor.HeadMountedDisplay);
CheckResult(Xr.GetSystem(Instance, in getInfo, ref system_id), "GetSystem");
}
