Skip to content

Installation

Dependencies

In order to build and use Orka you need to have:

  • Ada 2012 compiler (GNAT FSF from your Linux distribution or installed by Alire)

  • Alire

  • Wayland 1.18 (on Linux)

  • Video driver with EGL 1.5 and OpenGL 4.6 core profile

    Required EGL extensions

    Following table shows a list of client extensions. EGL 1.4 implementations might still support the extensions listed below.

    Client extension
    EGL_KHR_debug
    EGL_KHR_client_get_all_proc_addresses
    EGL_EXT_client_extensions
    EGL_EXT_device_enumeration
    EGL_EXT_device_query
    EGL_EXT_platform_base
    EGL_EXT_platform_device

    Following table shows a list of platform extensions:

    Platform extension
    EGL_KHR_create_context
    EGL_KHR_no_config_context
    EGL_KHR_surfaceless_context
    Required OpenGL extensions

    Following table shows a list of extensions that are part of OpenGL 4.x. Video drivers which do not officially support OpenGL 4.6 might still support a subset of the extensions listed below.

    Extension OpenGL Required for
    ARB_shader_draw_parameters 4.6 glTF
    ARB_direct_state_access 4.5
    KHR_context_flush_control 4.5
    ARB_clip_control 4.5 Reversed Z
    ARB_get_texture_sub_image 4.5 KTX writer
    ARB_buffer_storage 4.4
    ARB_clear_texture 4.4 Textures
    KHR_debug 4.3 Debugging
    ARB_clear_buffer_object 4.3
    ARB_compute_shader 4.3
    ARB_copy_image 4.3 Textures
    ARB_multi_draw_indirect 4.3 glTF
    ARB_shader_storage_buffer_object 4.3
    ARB_program_interface_query 4.3
    ARB_internalformat_query2 4.3 KTX writer
    ARB_texture_storage_multisample 4.3 Textures
    ARB_texture_storage 4.2 Textures
    ARB_shader_image_load_store 4.2 Barriers
    ARB_map_buffer_alignment 4.2
    ARB_separate_shader_objects 4.1
  • An x86-64 CPU with the AVX and F16C extensions

Optional dependencies:

  • lcov to generate a coverage report for the unit tests

  • make (on Linux)

CPU and OpenGL requirements

For the SIMD intrinsics, the x86 extensions AVX and F16C are needed. The following CPUs should have support for these extensions:

  • Intel Ivy Bridge Core i3 or newer (2012)
  • AMD Jaguar-based (2013) or Bulldozer-based (2011) or newer
  • AMD Zen-based (2017) or newer

On Linux, the following GPUs should support all the required OpenGL extensions:

Installing dependencies

Install the Alire package manager and then either run alr toolchain --select or install the compiler from your distribution:

$ apt install gnat gprbuild make

Install the Alire package manager and then either run alr toolchain --select or install the compiler from your distribution:

$ pacman -S gcc-ada make

Compile and install gprbuild-bootstrap, xmlada, libgpr, and then gprbuild from the AUR.

Install Alire package manager and then run alr toolchain --select.

Using Orka and AWT in your application

Add Orka to your application:

$ alr with orka --use=path/to/orka

To create an OpenGL context and window, add orka_awt:

$ alr with orka_awt --use=path/to/orka_awt

On Linux you need to copy the orka_awt/data/99-leds.rules file to /etc/udev/rules.d/ in order to be able to set the LED color of a gamepad.

Tools and examples

The project provides tools to view glTF models, KTX textures, and to display the OpenGL version and list the available extensions:

$ make tools

and then go to the orka_tools folder and run one of the provided executables from there. See alr run --list for a list.

The project contains some examples that demonstrate the basic usage of the library. Build the example programs as follows:

$ make examples

and then go to the examples folder and run one of the provided executables from there.

Running tests

The project contains a set of unit tests. Use make tests to build and run the unit tests. A coverage report can be generated if lcov is installed:

$ make clean
$ make tests
$ make coverage
$ make clean

Rendering your first triangle

After having installed Orka, you might want to skip the next few chapters and jump to Rendering to get an introduction to rendering and learn how you can render your first triangle on the screen.