Headless Vulkan examples

Vulkan Leave a comment

I have just added two minimal, mostly self-contained cross-platform headless Vulkan examples to my open source C++ Vulkan repository. Unlike the other examples in my repository these two don’t require a surface (created from a window) and as such can be run on systems with no window compositor.

The intention behind the two examples is to show how Vulkan can be used for running graphics and compute tasks without the need for an actual user interface to be present i.e. in the form of a window, often called “headless mode”. Those could e.g. be run on headless cloud-hosted server instances (like AWS once they add support) with Vulkan support.

Continue reading →

How to shrink down a git(hub) repository

Default, Technical Leave a comment

Starting point

With my Vulkan C++ example github repository approaching 200 MB in size I decided it was about time to shrink it down to a reasonable size again. Shrinking a git(hub) repository isn’t just about deleting locally present files but requires cleaning up the history as files that have been removed are still present in the repository’s history and therefore still contribute to it’s size.

A big chunk of the repo’s size is caused by binary assets like textures and 3d models. When I started out with my Vulkan example there were only a few assets so I just added them to the repository. In hindsight this was the wrong decision, so one of my primary goals was to remove all those assets from the repository and it’s history. I already stopped adding assets while I did some examples using HDR textures and moved them into a separate asset pack that needs to be downloaded to actually run these examples. After removing the assets I’ll no longer add any of them to the repo but rather put them into the separate asset pack.

So in this article I’ll try to describe how to shrink down a long running repository without having to recreate it. For my Vulkan examples this resulted in a much smaller repository that’s a lot faster to clone.
Continue reading →

Delphi/Pascal OpenGL Header updated to 4.6

OpenGL, Leave a comment

The Delphi/Pascal OpenGL headers have been updated to support OpenGL 4.6. The current version of this header can always be found at the github repository, the 4.6 release has also been tagged.

This version adds support for all ARB extensions added to OpenGL 4.6 and brings a few cross-platform fixes (mostly for Free Pascal) along with a few fixes and added constants for a few extensions that have been missing.

The header supports pretty much all Delphi and recent Free Pascal versions and should work on Windows, Linux (FPC only) and Mac OSX.

Continue reading →

The Vulkan Device Simulation Layer

Default, Vulkan Leave a comment

LunarG recently made the new Vulkan Device Simulation layer public. This is a Vulkan instance level layer that injects physical device properties, limits and features based on a json input file, simulating different features than the actual Vulkan device you are running on. The idea behind this is to help developers check if their Vulkan applications can handle devices with missing features and tighter limits without having to actually run on a such a device. It’s not an emulation (like a software rasterizer, e.g. WARP for DirectX) and only affects queries against the device limits and features, so you can’t magically get e.g. tessellation support on a device that doesn’t support it by using this layer.

But still this is a nice addition to the Vulkan eco system and is especially handy for smaller devs that don’t own all the different devices they intend to run their applications on. With this layer you check your fallback paths and how your application handles missing device features.
Continue reading →

iOS and macOS support added to the Vulkan examples

Vulkan One Comment

Thanks to a contribution from Bill Hollings, one of the developers from MoltenVK , my open source C++ Vulkan examples now also support Apple’s iOS and macOS platforms.

MoltenVK is a commercial Vulkan implementation that runs on top of Apple’s Metal api with a free trial available.

Details on how to build and run the examples for those platforms can be found in this readme.

Note that not all examples will work on iOS or macOS due to the differences in supported features like geometry or tessellation shaders not being available in Metal (1).

Vulkan Hardware Capability Viewer 1.4 released

Vulkan, , , View all 3 comments

A new version of the Vulkan Hardware Capability Viewer is now available for all platforms (Windows, Linux, Android). This is the biggest update since I released this tool, including lots of new features that also brought along a few changes to the online database. I also decided to drop the “beta” tag now that more than 1,300 reports have been uploaded, making this the first non-beta release of the Vulkan Hardware Capability viewer.

New features

  • Added support for new features and properties provided via VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2
    • Currently supported:
      • VK_KHR_push_descriptor
      • VK_EXT_discard_rectangles
      • VK_KHX_multiview
      • VK_NVX_multiview_per_view_attributes
  • Reports can now be saved to disk via command line using the -s argument (without invoking the UI)
    • Example : vulkanCapsViewer -s my_device.json
  • Added pipeline cache UUID
  • Exported JSON is now compatible with vkjson_info from LunarG SDK
  • Added Android platform info
    • Device model and manufacturer
    • Build information
  • UI improvements 
    • Updated layout and UI scaling 
    • Support for high DPI scaling
    • Touch scrolling for mobile devices (Android)

Bugfixes

  • Fixed unauthorized access to SSL libraries message on Android 6.0 and newer

Continue reading →

Updates to the Vulkan hardware database

Vulkan Leave a comment

Server-side processing (performance)

In preparation for the next release of the Vulkan Hardware Capability Viewer I published a major change to the Vulkan online hardware database at http://vulkan.gpuinfo.org/.

Up until now all data was handled client-side, so when loading up the report listing all reports were fetched and displayed by the client. While this was more or less fine in the beginning, delivering all reports to the client even if only the 25 newest ones were visible now takes several seconds (even on a fast connection) and fetching all rows for each visitor is also putting strain on the database.

So I updated the report listing page (that does pretty much all the heavy lifting) to use server-side processing. So instead of the client fetching all data and handling paging, ordering, sorting and filtering this is now done by the database (that’s what databases are best at after all).

Continue reading →

Physically based rendering and moving (hdr) assets out of the repository

Vulkan Leave a comment

The last days (and weeks) I’ve been working on a Vulkan example implementing physically based rendering with image based lighting (you can find a nice article with lots of details over at Trent Reed’s blog) and just pushed it to my public github repository.

  

While working on this demo I realized that putting all the binary assets (models and esp. textures) in the repository might not have been a great idea. They quickly bloat the size of the repository and once a binary asset is there you won’t be able to completely remove it (to shrink the repo again) unless you actually rewrite the history. But with the repository being public with almost 400 forks and numerous pull requests this pretty much a no-go.

Continue reading →