Build Intel® oneAPI Rendering Toolkit Libraries on Windows* OS

Published: 12/04/2020   Last Updated: 07/15/2021

This article describes how to build Intel® oneAPI Rendering Toolkit (Render Kit) libraries from sources on Windows* OS. Use this guide if you want to:

  • Review sample program source and edit them to understand API usage.
  • Get critical performance optimizations of core library performance by way of Intel® Implicit SPMD Program Compiled (Intel® ISPC).
  • Quickly integrate Intel oneAPI Rendering Toolkit libraries into your own production projects.
  • Integrate typical third-party imaging libraries and interactive windowfile implementing a superbuild from itsing libraries.

NOTE: This walkthrough explains how to build components for a non-administrator system user. Administrator prerequisites are minimal.

IMPORTANT: Skipping sections is not recommended for first-time users.

Prerequisites

Software prerequisites
  • Microsoft Visual Studio* 2017 or higher. This article uses Microsoft Visual Studio 2019
  • CMake* 3.12 or higher
  • Git* Large File Storage (Git* LFS)
  • Python* 2.7 or higher
  • Intel® Implicit SPMD Program Compiler (Intel® ISPC)
Optional
  • GLFW3*. This article uses GLFW 3.3.2.
  • ImageMagick*
  • vcpkg*
Estimated time

Automatic build: 15 - 20 minutes

Manual build: 45 - 60 minutes

Library Source Locations

You can use one of the following ways to get the source code:

  • Build the Intel oneAPI Rendering Toolkit using automated scripts:
    1. Download the Intel® oneAPI Rendering Toolkit distribution from the Intel oneAPI Rendering Toolkit product page as a full-package local installer or online installer. For more information, see Installation Guide for Intel® oneAPI Toolkits.
    2. After you download and install the Intel oneAPI Rendering Toolkit, you can get the component sources using a CMake script located at <install-dir>/rkutil. By default, <install-dir> is C:\Program Files (x86)\Intel\oneAPI.
  • Build the Intel oneAPI Rendering Toolkit manually:
    1. Check out sources for each component separately from corresponding GitHub* portals.
    2. If you choose this option, make sure to check out components versioned for the same oneAPI release as they are validated together. See the Release Notes pages for the toolkit component version manifests. Use the tags listed in the GitHub repositories to check out the corresponding component versions.

The component sections below provide instructions for both automatic and manual building options. Both instructions use Intel ISPC, which improves and optimizes core library performance.

Stage a Build Directory

NOTE: This walkthrough uses the Microsoft Visual Studio 2019 developer environment. You can use Microsoft Visual Studio 2017 and other standard C/C++ compilation toolchains instead with CMake* generators.

  1. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Create a directory for library sources at a writable location. For example, create a rk folder in the %USERPROFILE% directory. By default,  %USERPROFILE% is C:\Users\<username>.
    cd %USERPROFILE%
    mkdir rk
    cd rk

     

Set Up Dependencies

Install CMake*

CMake 3.12 or higher is required to build the Intel oneAPI Rendering Toolkit libraries. Downoad and install a recent version of CMake from https://cmake.org/.

NOTE: Microsoft Visual Studio 2019 includes CMake 3.17.x. However, using this included CMake for building the libraries may result in errors. You are recommended to use the CMake from the cmake.org instead.

To verify that the CMake is installed correctly:

  1. Open a command prompt.
  2. Run the following commands to check the CMake version and location:
    cmake --version
    where cmake

    If the CMake version or location printed is incorrect or the location is not found, add it to the PATH environment variable:

    set PATH=<cmake-install-dir>\bin;%PATH%

     

Install Git* LFS for Intel® Open Image Denoise

Intel® Open Image Denoise uses pre-trained networks in a .tza format at build time. These are large files posted on GitHub* that require Git* Large File Storage (Git* LFS) support to download.

To check if your installation of Git already has the LSF support, run the following commands:

where git
git lfs env

If your Git does not support LFS, install Git with LFS support from https://git-lfs.github.com/.

Optional: BuilGLFW3*

GLFW3* is used as an interfacing layer for OpenGL*-based drawing for reference applications. This article uses GLFW 3.3.2. GLFW3 is not required for the Intel oneAPI Rendering Toolkit libraries, but it is highly recommended because some library samples use it to draw outputs to GUI windows. If you target a headless environment, you can explore the GUI samples as they demonstrate key library API features.

From the rk directory:

  1. Get the GLFW3 3.3.2 sources from the Git repository:
    git clone --no-checkout https://github.com/glfw/glfw glfw3
    cd glfw3
    git fetch --tag
    git checkout tags/3.3.2

     

  2. Create a directory to stage the build:
    mkdir build
    cd build

     

  3. Build the GLFW3 library:
    cmake .. -G “Visual Studio 16 2019” -A x64 -DCMAKE_INSTALL_PREFIX=..\install -DBUILD_SHARED_LIBS=ON
    cmake --build . --config Release --target INSTALL -- -m
  4. Add GLFW3 to the glfw3_DIR environment variable:
    set glfw3_DIR=%USERPROFILE%\rk\glfw3\install

     

Optional: Install an Image Viewer

Some sample applications use images in .pfm and .ppm formats. You need an image viewer supporting these formats to open them. This article uses ImageMagick* to stage, convert, and review input and output images.

After downloading and installing this viewed:

  1. Add it to the PATH environment variable to make the development easier:
    set PATH=<imagemagick-install-dir>\ImageMagick-7.0.10-Q16-HDRI;%PATH%

     

  2. Check that the viewer is configured correctly:
    where magick

     

Optional: Build Third-Party Libraries with vcpkg*

This step takes most of time (about 55 minutes). The following libraries are optional, but they can be helpful for understanding and exploring Intel oneAPI Rendering Toolkit libraries. The vcpkg* package with all libraries takes up around 7 GB after installation is complete. OpenImageIO*, OpenVDB*, libjpeg-turbo*, and libpng* are recommended because they extend input and output capabilities of sample programs.

To install the vcpkg libraries:

  1. Go to the rk directory:
    cd %USERPROFILE%\rk

     

  2. Set up vcpkg:
    1. Get the vcpkg sources from Git:
      git clone https://github.com/Microsoft/vcpkg.git

       

    2. Install the vcpkg:
      cd vcpkg
      .\bootstrap-vcpkg.bat

       

  3. Install the recommended imaging libraries:
    .\vcpkg install openimageio:x64-windows openvdb:x64-windows libjpeg-turbo:x64-windows libpng:x64-windows

     

Install Python* 

Intel® Open Image Denoise requires Python* 2 or Python 3 x86-64. You can download it from the https://www.python.org/.

After installing, add Python to the PATH environment variable:

set PATH=C:\Python3;%PATH%

Check that Python is installed and set up correctly:

where python

Build the Libraries Automatically

  1. Go to the build rk directory:
    cd %USERPROFILE%\rk

     

  2. Set proxy if it is required for your network connection:
    set HTTPS_PROXY=<proxy>.<company>.com:<port>
    set HTTP_PROXY=<proxy>.<company>.com:<port>
    set http_proxy=<proxy>.<company>.com:<port>
    set https_proxy=<proxy>.<company>.com:<port>
  3. Get the superbuild  files:
    • From the installed distribution, copy the rkUtil, which contains provisions that are not core Intel oneAPI Rendering Toolkit libraries:
      mkdir superbuild
      xcopy /e "<install-dir>\rkutil\latest\superbuild*" superbuild\.
      cd superbuild

       

    • From GitHub*repository:
      git clone https://github.com/RenderKit/superbuild superbuild
      cd superbuild

       

  4. Turn on sample building. Open a CMakeLists.txt for editing in a preferred text editor and enable one or more of the toggles below for component samples you want to build:

    …
    -DEMBREE_TUTORIALS=ON
    …
    -DBUILD_EXAMPLES=ON
    …
    -DOIDN_APPS=ON
    …
    -DOSPRAY_ENABLE_APPS=ON

     

  5. Optional: Turn on the OpenImageIO to enable extended texture support for Intel® OSPRay Studio:

    -DENABLE_OPENIMAGEIO=ON

     

  6. Save the file.

  7. Create a directory to stage the build:

    mkdir build
    cd build

     

  8. Configure the component build:

    cmake .. -G ”Visual Studio 16 2019” -A x64

     

  9. Build the libraries:

    cmake --build . --config Release

    NOTE: At this step, proxy settings may cause download timeouts.

  10. Stage Intel® oneAPI Threading Building Blocks headers in the same folder as built executables:

    copy oneapi-tbb-2021.2.0\unpacked\tbb\bin\intel64\vc14\*.dll install\bin\.

     

  11. Navigate to the default install directory with the CMake script:

    cd install\bin

     

  12. Check the interactive GUI sample programs:

    1. Intel® OSPRay sample:

      ospExamples.exe

       

    2. Intel® Open Volume Kernel Library (Intel® Open VKL) sample:

      vklExamples.exe

       

    3. Intel® Embree sample:

      triangle_geometry.exe

       

    4. Intel® Open Image Denoise sample:
      1. Download test images for Intel Open Image Denoise:

        PowerShell Invoke-WebRequest https://openimagedenoise.github.io/images/mazda_64spp_input.jpg -Outfile mazda_64spp_input.jpg
        PowerShell Invoke-WebRequest https://openimagedenoise.github.io/images/mazda_firsthit_512spp_albedo.jpg -Outfile mazda_firsthit_512spp_albedo.jpg

         

      2. Convert the images to the Intel Open Image Denoise-friendly format with ImageMagick:

        magick convert -resize 1280x720 -endian LSB mazda_64spp_input.jpg input.pfm
        magick convert -endian LSB mazda_firsthit_512spp_albedo.jpg albedo.pfm

         

      3. Denoise the test images with the Intel Open Image Denoise sample: 

        oidnDenoise.exe -ldr input.pfm -alb albedo.pfm -o output.pfm

         

      4. Open the result images with ImageMagick:

        imdisplay output.pfm

At this point, you can edit sources and recompile the sample applications as needed. If you used the Microsoft Visual Studio generator, you can review the sources with the Microsoft Visual Studio GUI from the generated component solution files (.sln).

Build the Libraries Manually

Building the libraries manually is recommended if you want to edit or add modules to one or more Intel oneAPI Rendering Toolkit libraries.

Set Up Dependencies

Configure the Intel® Implicit SPMD Program Compiler

Intel® Implicit SPMD Program Compiler (Intel® ISPC) is a compiler tuned for wide vector instructions available on Intel® architectures. Using the Intel ISPC with the Intel oneAPI Rendering Toolkit is recommended because it can greatly improve performance.

To configure the Intel ISPC for the Intel oneAPI Rendering Toolkit:

  1. Download the Intel ISPC 1.15.0 binary package from https://github.com/ispc/ispc/releases. You can use the following PowerShell* command:
    PowerShell Invoke-WebRequest https://github.com/ispc/ispc/releases/download/v1.15.0/ispc-v1.15.0-windows.zip -Outfile %USERPROFILE%\Downloads\ispc-v1.15.0-windows.zip

     

  2. Extract the binary to  the rk directory. You can do this from the PowerShell with the following command:

    Powershell Expand-Archive -Force %USERPROFILE%\Downloads\ispc-v1.15.0-windows.zip ispc-v1.15.0-windows
  3. Add the Intel ISPC to the PATH environment variable so that component libraries can access it:

    set PATH=%USERPROFILE%\rk\ispc-v1.15.0-windows\bin;%PATH%
  4. Check that the Intel ISPC is installed and configured correctly:

    where ispc

     

Get the Intel® oneAPI Threading Building Blocks

Intel® oneAPI Threading Building Blocks (oneTBB) is used for tasking within the infrastructure for Intel oneAPI Rendering Toolkit libraries. oneTBB is recommended to use for building Intel oneAPI Rendering Toolkit libraries, but there are other build-time configurable options, for example, OpenMP*.

IMPORTANT: Use the same oneTBB library version for all Intel oneAPI Rendering Toolkit components. Recommended version is oneTBB 2021.1 or higher. This guide uses Intel oneAPI Rendering Toolkit with oneTBB 2021.2.0.

  1. Download and install the package using one of the following:
    • Download the package from the GitHub* https://github.com/oneapi-src/oneTBB/releases/tag/v2021.2.0 and unpack it.
    • Download and unpack the package using PowerShell:
      PowerShell Invoke-WebRequest https://github.com/oneapi-src/oneTBB/releases/download/v2021.2.0/oneapi-tbb-2021.2.0-win.zip -Outfile %USERPROFILE%\Downloads\oneapi-tbb-2021.2.0-win.zip
      Powershell Expand-Archive -Force %USERPROFILE%\Downloads\oneapi-tbb-2021.2.0-win.zip .

       

Build rkcommon

rkcommon is a support library used by the Intel oneAPI Rendering Toolkit components. It abstracts common math and vectorization operations, tasking implemented with the oneTBB, operating system input and output, networking, and memory capabilities to use in Intel oneAPI Rendering Toolkit components. rkcommon is not component specific. Intel OSPray and Intel Open VKL can automatically download and build rkcommon. However, when building more than one Intel oneAPI Rendering Toolkit library, you should build the rkcommon manually so that all components reference the same version of rkcommon.

  1. Go to the rk build directory:
    cd %USERPROFILE%\rk

     

  2. Get rkcommon 1.6.1 sources from the Git* repository:
    git clone --no-checkout https://github.com/ospray/rkcommon.git rkcommon
    cd rkcommon 
    git fetch --tags
    git checkout tags/v1.6.1

     

  3. Create a directory to stage the rkcommon build:
    mkdir build
    cd build
  4. Stage oneTBB headers:
    cmake .. -G"Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=../install -DRKCOMMON_TBB_ROOT="%USERPROFILE%\rk\oneapi-tbb-2021.2.0"

     

  5. Configure, build, and install rkcommon:
    cmake --build . --config Release --target INSTALL -- -m
    cd ..\install\bin
    rkcommon_test_suite.exe

    You should see the following output:

    ===============================================================================
    All tests passed (2000399 assertions in 36 test cases)
    

     

Deployed bin, include, and lib directories contain a test executable, headers, libraries, and CMake references.

Build the Libraries

Build Intel® Embree

NOTE: Before building Intel Embree, make sure rkcommon and other prerequisites are available.

  1. Launch a new shell session. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Go to the build directory:
    cd %USERPROFILE%\rk

     

  3. Get the Intel Embree sources from a Git* repository:
    git clone --no-checkout https://github.com/embree/embree.git embree
    cd embree
    git fetch --tags
    git checkout tags/v3.13.0

     

  4. Create a directory to stage the build:
    mkdir build
    cd build

     

  5. Build Intel Embree with imaging input and output libraries:
    cmake .. -G"Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=../install -DEMBREE_TBB_ROOT="%USERPROFILE%\rk\oneapi-tbb-2021.2.0" -DCMAKE_PREFIX_PATH=%USERPROFILE%\rk\vcpkg\installed\x64-windows -DPNG_LIBRARIES=%USERPROFILE%\rk\vcpkg\installed\x64-windows\lib\libpng16.lib 
    cmake --build . --config Release --target INSTALL -- -m

    NOTE: The building can take up to 35 minutes. Use the -m option to parallelize the build.

To verify your Intel Embree build and installation, you can run a sample:

  1. Go to sample directory:
    cd %USERPROFILE%\rk\embree\install\bin
  2. Make sure the sample applications can access the oneTBB and imaging DLLs. Append the oneTBB .dll directory and imaging .dll directory to your PATH environment variable.
    set PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0\redist\intel64\vc14;%USERPROFILE%\rk\vcpkg\installed\x64-windows\bin;%PATH%
  3. Run the interactive triangle geometry sample:
    triangle_geometry.exe

    Successful launch displays an interactive window rendering a cube. If the cube does not appear within a GUI window, please check your GUI and runtime path configuration.

 

Build Intel® Open Volume Kernel Library

NOTE: Before building Intel® Open Volume Kernel Library (Intel® Open VKL), make sure rkcommon and other prerequisites are available.

  1. Launch a new shell session. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Go to the build directory:
    cd %USERPROFILE%\rk
  3. Get the Intel Open VKL sources from a Git repository:

    git clone https://github.com/openvkl/openvkl.git openvkl
    cd openvkl
    git fetch --tag
    git checkout tags/v0.13.0

     

  4. Create a directory to stage the build:

    mkdir build
    cd build
  5. Set environment variables for other components that Intel Open VKL required for building:

    set rkcommon_DIR=%USERPROFILE%\rk\rkcommon\install
    set TBB_ROOT=%USERPROFILE%\rk\oneapi-tbb-2021.2.0
    set embree_DIR=%USERPROFILE%\rk\embree\install
    set glfw3_DIR=%USERPROFILE%\rk\glfw3\install
  6. Configure Intel Open VKL build:

    cmake .. -G"Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=..\install
  7. Build Intel Open VKL:

    cmake --build . --config Release --target INSTALL -- -m

     

To verify your Intel Open VKL build and installation, you can run a sample:

  1. Go to bin directory with samples:
    cd %USERPROFILE%\rk\openvkl\install\bin
  2. Make sure the Intel Open VKL samples can access component runtime libraries. Add .dll directories for oneTBB, rkcommon, Intel Embree, imaging libraries, and GLFW3 to your PATH environment variable:
    set PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0\redist\intel64\vc14;%USERPROFILE%\rk\rkcommon\install\bin;%USERPROFILE%\rk\embree\install\bin;%USERPROFILE%\rk\vcpkg\installed\x64-windows\bin;%USERPROFILE%\rk\glfw3\install\bin;%PATH%
  3. Run Intel Open VKL samples. If you see any runtime errors, make sure the samples can access tbb.dll, rkcommon.dll, and embree3.dll as described in the step above:
    • Hello-world vklTutorial sample:

      vklTutorial.exe

      You should see the application output printed to the command prompt.

    • Hello-world vklTutorialISPC sample with Intel ISPC acceleration:

      vklTutorialISPC.exe

      You should see the application output printed to the command prompt.

    • vklExample sample, which renders results to screen through a graphical interface:

      vklExamples.exe

      You should see the application output in a new GUI window.

NOTE: Intel Open VKL has a CMakeLists.txt file implementing a superbuild from its superbuild directory. The superbuild can automatically download and install validated versions of Intel Open VKL dependencies, such as oneTBB, rkcommon, GLFW3, Intel Embree, OpenVDB*. If you work with Intel Open VKL only, consider using the superbuild.

 

Build Intel® Open Image Denoise

  1. Launch a new shell session. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Ensure Python, Intel ISPC, and Git with LFS are available from the shell:
    where python
    where ispc
    where git
    git lfs env

    You should see a path to each tool. Otherwise, add the appropriate directories to your PATH environment variable.

  3. Go to the build directory:
    cd %USERPROFILE%\rk
  4. Get the Intel Open Image Denoise sources from a Git repository:

    1. Clone the Intel Open Image Denoise sources:

      git clone --recursive https://github.com/OpenImageDenoise/oidn.git oidn
      cd oidn
      git fetch --tags
      git checkout tags/v1.4.0

       

    2. Update the mkl-dnn and the weights submodules:

      git submodule update --init --recursive

       

  5. Important: Check that %USERPROFILE%\rk\oidn\weights contains files that are larger than 200 bytes:

    dir %USERPROFILE%\rk\oidn\weights

    These files are pre-trained network required for building the Intel Open Image Denoise, and the size of each file should be at least 5 MM. If the size is smaller that 200 bytes, it means that they are downloaded incorrectly without using git-lfs. You can download the pretrained network files manually:

    1. Clone the oidn-weights directory from the repository:

      git clone https://github.com/OpenImageDenoise/oidn-weights.git oidn-weights
      cd oidn-weights
      git fetch --tag
      git checkout tags/v1.4.0
      cd ..

       

    2. Copy the files to the weights directory:

      copy /Y oidn-weights weights

       

  6. Create a build directory:

    mkdir build
    cd build
  7. Configure the build:

    • If you have libopenimageio, configure the build with libopenimageio enabled for Intel Open Image Denoise sample applications:

      set OPENIMAGEIO_ROOT=%USERPROFILE%\rk\vcpkg\installed\x64-windows
      cmake .. -G”Visual Studio 16 2019” -A x64 -DCMAKE_PREFIX_PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0 -DCMAKE_INSTALL_PREFIX=../install -DOIDN_APPS=ON -DOIDN_APPS_OPENIMAGEIO=ON

      NOTE: You can use the OpenImageIO* library to load and unload images for Intel Open Image Denoise samples, but it is not required. OpenImageIO dependencies include many imaging and productivity libraries common to other applications. vcpkg manager is recommended to install OpenImageIO instead of building it.

    • If you do not have libopenimageio:

      cmake .. -G”Visual Studio 16 2019” -A x64 -DCMAKE_PREFIX_PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0 -DCMAKE_INSTALL_PREFIX=../install -DOIDN_APPS=ON -DOIDN_APPS_OPENIMAGEIO=ON

      NOTE: CMake may report OpenImageIO warnings, but the build should continue.

  8. Build the Intel Open Image Denoise:

    cmake --build . --config Release --target INSTALL -- -m

     

To verify your Intel Open Image Denoise build and installation, run a sample:

  1. Go to the bin directory with samples:
    cd %USERPROFILE%\rk\oidn\install\bin

     

  2. Download an example noisy input file mazda_64spp_input.jpg. You can use PowerShell:
    PowerShell Invoke-WebRequest https://openimagedenoise.github.io/images/mazda_64spp_input.jpg -Outfile mazda_64spp_input.jpg

     

  3. Download the corresponding albedo file mazda_firsthit_512spp_albedo.jpg. You can use PowerShell:
    PowerShell Invoke-WebRequest https://openimagedenoise.github.io/images/mazda_firsthit_512spp_albedo.jpg -Outfile mazda_firsthit_512spp_albedo.jpg

     

  4. Convert both images to a .pfm format with ImageMagick:
    magick convert <inputfile.jpg> -endian LSB -resize 1280x720 <outputfile.pfm>

    NOTE: Use the  -resize ​option to make sure that the noisy input and albedo input images are of the same size.

  5. Set path for runtime DLL libraries:
    set PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0\redist\intel64\vc14;%USERPROFILE%\rk\vcpkg\installed\x64-windows\bin;%PATH%
  6. Run the oidnDenoise sample application:
    oidnDenoise.exe -ldr<your_noisy_input_file>.pfm -alb <your_albedo_file>.pfm -o denoise.pfm
  7. Open the resulting images:
    magick imdisplay denoise.pfm

     

The sample outputs a denoised ray-traced image. Notice the reduced noise underneath the vehicle when using the sample vehicle image as an input. 

Build Intel® OSPRay

NOTE: Intel OSPRay requires other Intel oneAPI Rendering Toolkit libraries to be built first.

  1. Launch a new shell session. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Go to the build directory:
    cd %USERPROFILE%\rk\
  3. Get the Intel OSPRay sources from a Git repository:

    git clone https://github.com/ospray/ospray.git ospray
    cd ospray
    git fetch --tag
    git checkout tags/v2.6.0

     

  4. Create a new directory to stage the build:

    mkdir build
    cd build
  5. Set up environment variables for library build-time dependencies:

    set TBB_ROOT=%USERPROFILE%\rk\oneapi-tbb-2021.2.0
    set rkcommon_DIR=%USERPROFILE%\rk\rkcommon\install
    set embree_DIR=%USERPROFILE%\rk\embree\install
    set glfw3_DIR=%USERPROFILE%\rk\glfw3\install
    set openvkl_DIR=%USERPROFILE%\rk\openvkl\install
  6. Optional: To enable Intel Open Image Denoise support in Intel OSPRay samples:
    set OpenImageDenoise_DIR=%USERPROFILE%\rk\oidn\install

     

  7. Configure the build:

    cmake .. -G"Visual Studio 16 2019" -A x64 -DCMAKE_PREFIX_PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0 -DCMAKE_INSTALL_PREFIX=../install -DOSPRAY_MODULE_DENOISER=ON

    NOTE: DOSPRAY_MODULE_DENOISER=ON enables denoiser control in the ospExamples application. You can omit this build-time control if you do not use the denoiser.

  8. Optional: If you want to extend Intel OSPRay with additional modules or other custom module features, run cmake-gui.exe and reconfigure:

    cmake-gui.exe .

     

  9. Build and install the Intel OSPRay:

    cmake --build . --config Release --target INSTALL -- -m

     

To verify your Intel OSPRay build and installation, run the samples:

  1. Go to bin directory with samples:
    cd %USERPROFILE%\rk\ospray\install\bin
  2. Set the PATH variable to enable dynamic search for component runtimes:
    set PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0\redist\intel64\vc14;%USERPROFILE%\rk\openvkl\install\bin;%USERPROFILE%\rk\oidn\install\bin;%USERPROFILE%\rk\rkcommon\install\bin;%USERPROFILE%\rk\embree\install\bin;%USERPROFILE%\rk\glfw3\install\bin;%USERPROFILE%\rk\vcpkg\installed\x64-windows\bin;%PATH%
  3. Run the ospTutorial Hello-World sample. This sample does not interface with the GUI environment:
    ospTutorial.exe
  4. Review the generated .ppm files with your preferred image viewer. For example, to open the images in the ImageMagick:
    dir *.ppm
    magick display accumulatedFrame.ppm
    magick display firstFrame.ppm

     

Run the ospExamples viewer:

ospExamples.exe

ospExamples combines much of the functionality of Intel oneAPI Rendering Toolkit libraries into an interactive reference program.

  • Switch between typical geometries using the Scene drop-down.
  • Switch between pathtracer and scivis renderers using the Renderer drop down.
  • Control the virtual camera position by clicking and holding left, middle, or right mouse button and moving the mouse.

The ospExamples reference program source is a great starting point for reviewing how scene geometry passes through Intel OSPRay and ultimately back to the interactive window.

Build Intel® OSPRay Studio

NOTE: Intel® OSPRay Studio requires Intel OSPRay.

  1. Launch a new shell session. From the Start menu, enter x64 Native Tools Command Prompt for VS 2019.
  2. Go to the build directory:
    cd %USERPROFILE%\rk\

     

  3. Get the Intel OSPRay sources from a Git repository:
    git clone https://github.com/ospray/ospray_studio.git ospray_studio
    cd ospray_studio
    git fetch --tag
    git checkout tags/v0.7.0

     

  4. Create a directory to stage the build:
    mkdir build
    cd build

     

  5. Set up environment variables for library build-time dependencies:
    set TBB_ROOT=%USERPROFILE%\rk\oneapi-tbb-2021.2.0
    set rkcommon_DIR=%USERPROFILE%\rk\rkcommon\install
    set embree_DIR=%USERPROFILE%\rk\embree\install
    set glfw3_DIR=%USERPROFILE%\rk\glfw3\install
    set openvkl_DIR=%USERPROFILE%\rk\openvkl\install

     

  6. Optional: Enable Intel Open Image Denoise support in Intel OSPRay samples:
    set OpenImageDenoise_DIR=%USERPROFILE%\rk\oidn\install
    set ospray_DIR=%USERPROFILE%\rk\ospray\install

     

  7. Configure the build:
    cmake .. -G"Visual Studio 16 2019" -A x64 -DCMAKE_PREFIX_PATH=%USERPROFILE%\rk\oneapi-tbb-2021.2.0 -DCMAKE_INSTALL_PREFIX=../install

     

  8. Optional: If you want to extend the Intel OSPRay with additional modules or other custom module features, run cmake-gui.exe and reconfigure:
    cmake-gui.exe .

     

To verify your Intel OSPRay build and installation, run the samples:

  1. Go to the bin directory with samples:
    cd %USERPROFILE%\rk\ospray_studio\install\bin

     

  2. Run the ospStudio:
    ospStudio.exe

Notices and Disclaimers

Intel technologies may require enabled hardware, software or service activation.
No product or component can be absolutely secure.
Your costs and results may vary.
© Intel Corporation. Intel, the Intel logo, and other Intel marks are trademarks of Intel Corporation or its subsidiaries. Other names and brands may be claimed as the property of others.

No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document.
The products described may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.