diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 3396e48a28..483470e1af 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -26,7 +26,7 @@ jobs: python scripts/test.py build python scripts/test.py test - release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP: + release-macosx-x64-Release-CLANG-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP: secrets: inherit uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main with: @@ -34,7 +34,7 @@ jobs: artifact-out: release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP artifact-path: ./build/*.zip cmd: | - scripts/test.py configure platform:x64 build:Release compiler:ICX2023.0.0 ispc:ispc1.19.0 isas:SSE2-SSE42-AVX-AVX2 tasking:TBB2021.9.0 intensity:4 package:ZIP + scripts/test.py configure platform:x64 build:Release compiler:CLANG ispc:ispc1.19.0 isas:SSE2-SSE42-AVX-AVX2 tasking:TBB2021.9.0 intensity:4 package:ZIP scripts/test.py build scripts/test.py test @@ -106,28 +106,28 @@ jobs: binary-analysis: needs: - release-windows-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - - release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP + - release-macosx-x64-Release-CLANG-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - release-linux-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP secrets: inherit uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/binary_analysis.yml@main with: project: embree artifact-in-windows: release-windows-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - artifact-in-macos: release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP + artifact-in-macos: release-macosx-x64-Release-CLANG-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP artifact-in-linux: release-linux-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP path: "build/*.zip build/*.gz" antivirus-scan: needs: - release-windows-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - - release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP + - release-macosx-x64-Release-CLANG-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - release-linux-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP secrets: inherit uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/antivirus_scan.yml@main with: project: embree artifact-in-windows: release-windows-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP - artifact-in-macos: release-macosx-x64-Release-ICX2023_0_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP + artifact-in-macos: release-macosx-x64-Release-CLANG-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP artifact-in-linux: release-linux-x64-Release-ICX2023_1_0-ISPC1_19_0-TBB2021_9_0-PACKAGE-ZIP path: "build/*.zip build/*.gz" diff --git a/CHANGELOG.md b/CHANGELOG.md index 2b078a1684..ce8734681c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,11 @@ Version History --------------- +### Embree 4.1.0 +- Added support for Intel® Data Center GPU Max Series. +- Added ARM64 Linux support. +- Added EMBREE_BACKFACE_CULLING_SPHERES cmake option. The new cmake option defaults to OFF. + ### Embree 4.0.1 - Improved performance for Tiger Lake, Comet Lake, Cannon Lake, Kaby Lake, and Skylake client CPUs by using 256 bit SIMD instructions by default. diff --git a/README.md b/README.md index 3e3b2de8c0..0bbc51a14a 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -% Embree: High Performance Ray Tracing Kernels 4.0.1 +% Embree: High Performance Ray Tracing Kernels 4.1.0 % Intel Corporation Intel® Embree Overview @@ -7,8 +7,8 @@ Intel® Embree Overview Intel® Embree is a high-performance ray tracing library developed at Intel, which is released as open source under the [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0). Intel® Embree -supports x86 CPUs under Linux, macOS, and Windows; ARM CPUs on macOS; -as well as Intel® GPUs under Linux and Windows. +supports x86 CPUs under Linux, macOS, and Windows; ARM CPUs on Linux +and macOS; as well as Intel® GPUs under Linux and Windows. Intel® Embree targets graphics application developers to improve the performance of photo-realistic rendering applications. Embree is @@ -63,24 +63,14 @@ Supported Platforms Embree supports Windows (32-bit and 64-bit), Linux (64-bit), and macOS (64-bit). Under Windows, Linux and macOS x86 based CPUs are supported, -while ARM CPUs are currently only supported under macOS (e.g. Apple -M1). ARM support for Windows and Linux is experimental. +while ARM CPUs are currently only supported under Linux and macOS (e.g. +Apple M1). ARM support for Windows experimental. Embree supports Intel GPUs based on the Xe HPG microarchitecture (Intel® Arc™ GPU) under Linux and Windows and Xe HPC microarchitecture (Intel® Data Center GPU Flex Series and Intel® Data Center GPU Max Series) under Linux. -Currently the following products are supported and further products -will get enabled soon: - -- Intel® Arc™ A770 Graphics -- Intel® Arc™ A750 Graphics -- Intel® Arc™ A770M Graphics -- Intel® Arc™ A730M Graphics -- Intel® Arc™ A550M Graphics -- Intel® Data Center GPU Flex 170 - The code compiles with the Intel® Compiler, Intel® oneAPI DPC++ Compiler, GCC, Clang, and the Microsoft Compiler. To use Embree on the GPU the Intel® oneAPI DPC++ Compiler must be used. Please see section @@ -110,7 +100,7 @@ Windows Installation -------------------- Embree linked against Visual Studio 2015 are provided as a ZIP file -[embree-4.0.1.x64.vc14.windows.zip](https://github.com/embree/embree/releases/download/v4.0.1/embree-4.0.1.x64.vc14.windows.zip). After +[embree-4.1.0.x64.vc14.windows.zip](https://github.com/embree/embree/releases/download/v4.1.0/embree-4.1.0.x64.vc14.windows.zip). After unpacking this ZIP file, you should set the path to the `lib` folder manually to your `PATH` environment variable for applications to find Embree. @@ -120,13 +110,13 @@ Linux Installation ------------------ The Linux version of Embree is also delivered as a `tar.gz` file: -[embree-4.0.1.x86_64.linux.tar.gz](https://github.com/embree/embree/releases/download/v4.0.1/embree-4.0.1.x86_64.linux.tar.gz). Unpack +[embree-4.1.0.x86_64.linux.tar.gz](https://github.com/embree/embree/releases/download/v4.1.0/embree-4.1.0.x86_64.linux.tar.gz). Unpack this file using `tar` and source the provided `embree-vars.sh` (if you are using the bash shell) or `embree-vars.csh` (if you are using the C shell) to set up the environment properly: - tar xzf embree-4.0.1.x86_64.linux.tar.gz - source embree-4.0.1.x86_64.linux/embree-vars.sh + tar xzf embree-4.1.0.x86_64.linux.tar.gz + source embree-4.1.0.x86_64.linux/embree-vars.sh We recommend adding a relative `RPATH` to your application that points to the location where Embree (and TBB) can be found, e.g. `$ORIGIN/../lib`. @@ -136,12 +126,12 @@ macOS Installation ------------------ The macOS version of Embree is also delivered as a ZIP file: -[embree-4.0.1.x86_64.macosx.zip](https://github.com/embree/embree/releases/download/v4.0.1/embree-4.0.1.x86_64.macosx.zip). Unpack +[embree-4.1.0.x86_64.macosx.zip](https://github.com/embree/embree/releases/download/v4.1.0/embree-4.1.0.x86_64.macosx.zip). Unpack this file using `tar` and source the provided `embree-vars.sh` (if you are using the bash shell) or `embree-vars.csh` (if you are using the C shell) to set up the environment properly: - unzip embree-4.0.1.x64.macosx.zip source embree-4.0.1.x64.macosx/embree-vars.sh + unzip embree-4.1.0.x64.macosx.zip source embree-4.1.0.x64.macosx/embree-vars.sh If you want to ship Embree with your application, please use the Embree library of the provided ZIP file. The library name of that Embree @@ -166,7 +156,7 @@ set the `TBB_DIR` variable to the path containing `TBB-config.cmake` of a local TBB install, in case you do not have TBB installed globally on your system, e.g: - cmake -D embree_DIR=path_to_embree_package/lib/cmake/embree-4.0.1/ \ + cmake -D embree_DIR=path_to_embree_package/lib/cmake/embree-4.1.0/ \ -D TBB_DIR=path_to_tbb_package/lib/cmake/tbb/ \ .. @@ -278,8 +268,9 @@ C++11. Embree is tested with the following compilers: Linux + - Intel® oneAPI DPC++/C++ Compiler 2023.1.0 - Intel® oneAPI DPC++/C++ Compiler 2023.0.0 - - oneAPI DPC++/C++ Compiler 2022-12-14 + - oneAPI DPC++/C++ Compiler 2023-04-17 - Clang 5.0.0 - Clang 4.0.0 - GCC 10.0.1 (Fedora 32) AVX512 support @@ -287,6 +278,7 @@ Linux - GCC 7.3.1 (Fedora 27) AVX2 support - GCC 7.3.1 (Fedora 26) AVX2 support - GCC 6.4.1 (Fedora 25) AVX2 support + - Intel® Implicit SPMD Program Compiler 1.19.0 - Intel® Implicit SPMD Program Compiler 1.18.1 - Intel® Implicit SPMD Program Compiler 1.17.0 - Intel® Implicit SPMD Program Compiler 1.16.1 @@ -297,6 +289,7 @@ Linux macOS x86 + - Intel® C++ Classic Compiler 2023.1.0 - Intel® C++ Classic Compiler 2023.0.0 - Apple Clang 12.0.5 (macOS 11.7.1) @@ -402,13 +395,13 @@ The "oneAPI DPC++ Compiler" is more up-to-date than the "Intel(R) oneAPI DPC++/C++ Compiler" but less stable. The current tested version of the "oneAPI DPC++ compiler is - - [oneAPI DPC++ Compiler 2022-12-14](https://github.com/intel/llvm/releases/download/sycl-nightly%2F20221214/dpcpp-compiler.tar.gz) + - [oneAPI DPC++ Compiler 2023-04-17](https://github.com/intel/llvm/releases/download/sycl-nightly%2F20230417/dpcpp-compiler.tar.gz) The compiler can be downloaded and simply extracted. The oneAPI DPC++ compiler 2022-12-14 can be set up executing the following command in a Linux (bash) shell: - wget https://github.com/intel/llvm/releases/download/sycl-nightly%2F20221214/dpcpp-compiler.tar.gz + wget https://github.com/intel/llvm/releases/download/sycl-nightly%2F20230417/dpcpp-compiler.tar.gz tar xzf dpcpp-compiler.tar.gz source ./dpcpp_compiler/startup.sh @@ -432,7 +425,7 @@ through `EMBREE_SYCL_SUPPORT=ON`. Alternatively, you can download and run the installer of the - - [Intel(R) oneAPI DPC++/C++ Compiler 2023.0.0](https://www.intel.com/content/www/us/en/developer/articles/tool/oneapi-standalone-components.html#dpcpp-cpp). + - [Intel(R) oneAPI DPC++/C++ Compiler 2023.1.0](https://www.intel.com/content/www/us/en/developer/articles/tool/oneapi-standalone-components.html#dpcpp-cpp). After installation, you can set up the compiler by sourcing the `vars.sh` script in the `env` directory of the compiler install directory, for example, @@ -476,7 +469,7 @@ We tested Embree with the latest GPGPU driver Devel Release from and OpenCL(TM) Driver from that release is too old for Embree to work properly. Thus if no newer version of the GPGPU driver is available, you need to additionally install the latest compute runtime from here -[22.43.24595](https://github.com/intel/compute-runtime/releases/tag/22.43.24595.30). +[23.09.25812.14](https://github.com/intel/compute-runtime/releases/tag/23.09.25812.14). Unfortunately, these compute runtime packages are only available for Ubuntu 22.04. You can also install a newer version of the compute @@ -488,11 +481,13 @@ Windows Embree is tested using the following compilers under Windows: + - Intel® oneAPI DPC++/C++ Compiler 2023.1.0 - Intel® oneAPI DPC++/C++ Compiler 2023.0.0 - - oneAPI DPC++/C++ Compiler 2022-12-14 + - oneAPI DPC++/C++ Compiler 2023-04-17 - Visual Studio 2019 - Visual Studio 2017 - Visual Studio 2015 (Update 1) + - Intel® Implicit SPMD Program Compiler 1.19.0 - Intel® Implicit SPMD Program Compiler 1.18.1 - Intel® Implicit SPMD Program Compiler 1.17.0 - Intel® Implicit SPMD Program Compiler 1.16.1 @@ -617,7 +612,7 @@ The "oneAPI DPC++ Compiler" is more up-to-date than the "Intel(R) oneAPI DPC++/C++ Compiler" but less stable. The current tested version of the oneAPI DPC++ compiler is - - [oneAPI DPC++ Compiler 2022-12-14](https://github.com/intel/llvm/releases/download/sycl-nightly%2F20221214/dpcpp-compiler-win.tar.gz) + - [oneAPI DPC++ Compiler 2023-04-17](https://github.com/intel/llvm/releases/download/sycl-nightly%2F20230417/dpcpp-compiler-win.tar.gz) Download and unpack the archive and open the "x64 Native Tools Command Prompt" of Visual Studio and execute the following lines to properly configure the @@ -703,9 +698,9 @@ your application with such an Embree package. ### Windows Graphics Driver Installation In order to run the SYCL tutorials on HPG hardware, you first need to -install the proper graphics drivers for your graphics card from -[https://www.intel.com](https://www.intel.com). Embree will work with -graphics driver version 101.4027 or later. +install the graphics drivers for your graphics card from +[https://www.intel.com](https://www.intel.com). Please make sure to +have installed version 31.0.101.4314 or newer. CMake Configuration @@ -774,6 +769,14 @@ parameters that can be configured in CMake: surfaces facing a ray can be hit. This option is turned OFF by default. ++ `EMBREE_BACKFACE_CULLING_CURVES`: Enables backface culling for curves, + i.e. only surfaces facing a ray can be hit. This option is turned OFF + by default. + ++ `EMBREE_BACKFACE_CULLING_SPHERES`: Enables backface culling for spheres, + i.e. only surfaces facing a ray can be hit. This option is turned OFF + by default. + + `EMBREE_COMPACT_POLYS`: Enables compact tris/quads, i.e. only geomIDs and primIDs are stored inside the leaf nodes. @@ -1315,21 +1318,6 @@ Embree SYCL Known Issues quality, and GPU performance may not reflect that of the final product. -- Currently only the following Intel® Arc™ GPUs are support: - - - Intel® Arc™ A770 Graphics - - Intel® Arc™ A750 Graphics - - Intel® Arc™ A770M Graphics - - Intel® Arc™ A730M Graphics - - Intel® Arc™ A550M Graphics - -- Intel® Data Center GPU Max Series is currently not supported. - -- Ahead of time compilation is currently not working properly and you - will get this error during compilation: - - llvm-foreach: Floating point exception (core dumped) - - Compilation with build configuration "debug" is currently not working on Windows. @@ -1842,6 +1830,16 @@ Possible properties to query are: back face culling is enabled. This is only the case if Embree is compiled with `EMBREE_BACKFACE_CULLING` enabled. +- `RTC_DEVICE_PROPERTY_BACKFACE_CULLING_CURVES_ENABLED`: Queries + whether back face culling for curves is enabled. This is only the + case if Embree is compiled with `EMBREE_BACKFACE_CULLING_CURVES` + enabled. + +- `RTC_DEVICE_PROPERTY_BACKFACE_CULLING_SPHERES_ENABLED`: Queries + whether back face culling for spheres is enabled. This is only the + case if Embree is compiled with `EMBREE_BACKFACE_CULLING_SPHERES` + enabled. + - `RTC_DEVICE_PROPERTY_COMPACT_POLYS_ENABLED`: Queries whether compact polys is enabled. This is only the case if Embree is compiled with `EMBREE_COMPACT_POLYS` enabled. diff --git a/man/man3/RTCFeatureFlags.4embree4 b/man/man3/RTCFeatureFlags.4embree4 new file mode 100644 index 0000000000..d150c8b4c9 --- /dev/null +++ b/man/man3/RTCFeatureFlags.4embree4 @@ -0,0 +1,230 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "RTCFeatureFlags" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +RTCFeatureFlags - specifies features to enable + for ray queries +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +enum RTCFeatureFlags +{ + RTC_FEATURE_FLAG_NONE = 0, + + RTC_FEATURE_FLAG_MOTION_BLUR = 1 << 0, + + RTC_FEATURE_FLAG_TRIANGLE = 1 << 1, + RTC_FEATURE_FLAG_QUAD = 1 << 2, + RTC_FEATURE_FLAG_GRID = 1 << 3, + RTC_FEATURE_FLAG_SUBDIVISION = 1 << 4, + RTC_FEATURE_FLAG_POINT = ... , + RTC_FEATURE_FLAG_CURVES = ... , + + RTC_FEATURE_FLAG_CONE_LINEAR_CURVE = 1 << 5, + RTC_FEATURE_FLAG_ROUND_LINEAR_CURVE = 1 << 6, + RTC_FEATURE_FLAG_FLAT_LINEAR_CURVE = 1 << 7, + + RTC_FEATURE_FLAG_ROUND_BEZIER_CURVE = 1 << 8, + RTC_FEATURE_FLAG_FLAT_BEZIER_CURVE = 1 << 9, + RTC_FEATURE_FLAG_NORMAL_ORIENTED_BEZIER_CURVE = 1 << 10, + + RTC_FEATURE_FLAG_ROUND_BSPLINE_CURVE = 1 << 11, + RTC_FEATURE_FLAG_FLAT_BSPLINE_CURVE = 1 << 12, + RTC_FEATURE_FLAG_NORMAL_ORIENTED_BSPLINE_CURVE = 1 << 13, + + RTC_FEATURE_FLAG_ROUND_HERMITE_CURVE = 1 << 14, + RTC_FEATURE_FLAG_FLAT_HERMITE_CURVE = 1 << 15, + RTC_FEATURE_FLAG_NORMAL_ORIENTED_HERMITE_CURVE = 1 << 16, + + RTC_FEATURE_FLAG_ROUND_CATMULL_ROM_CURVE = 1 << 17, + RTC_FEATURE_FLAG_FLAT_CATMULL_ROM_CURVE = 1 << 18, + RTC_FEATURE_FLAG_NORMAL_ORIENTED_CATMULL_ROM_CURVE = 1 << 19, + + RTC_FEATURE_FLAG_SPHERE_POINT = 1 << 20, + RTC_FEATURE_FLAG_DISC_POINT = 1 << 21, + RTC_FEATURE_FLAG_ORIENTED_DISC_POINT = 1 << 22, + + RTC_FEATURE_FLAG_ROUND_CURVES = ... , + RTC_FEATURE_FLAG_FLAT_CURVES = ... , + RTC_FEATURE_FLAG_NORMAL_ORIENTED_CURVES = ... , + + RTC_FEATURE_FLAG_LINEAR_CURVES = ... , + RTC_FEATURE_FLAG_BEZIER_CURVES = ... , + RTC_FEATURE_FLAG_BSPLINE_CURVES = ... , + RTC_FEATURE_FLAG_HERMITE_CURVES = ... , + + RTC_FEATURE_FLAG_INSTANCE = 1 << 23, + + RTC_FEATURE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS = 1 << 24, + RTC_FEATURE_FLAG_FILTER_FUNCTION_IN_GEOMETRY = 1 << 25, + RTC_FEATURE_FLAG_FILTER_FUNCTION = ... , + + RTC_FEATURE_FLAG_USER_GEOMETRY_CALLBACK_IN_ARGUMENTS = 1 << 26, + RTC_FEATURE_FLAG_USER_GEOMETRY_CALLBACK_IN_GEOMETRY = 1 << 27, + RTC_FEATURE_FLAG_USER_GEOMETRY = ... , + + RTC_FEATURE_FLAG_32_BIT_RAY_MASK = 1 << 28, + + RTC_FEATURE_FLAG_ALL = 0xffffffff +}; +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]RTCFeatureFlags\f[R] enum specify a bit mask to enable specific +ray tracing features for ray query operations. +The feature flags are passed to the \f[C]rtcIntersect1/4/8/16\f[R] and +\f[C]rtcOccluded1/4/8/16\f[R] functions through the +\f[C]RTCIntersectArguments\f[R] and \f[C]RTCOccludedArguments\f[R] +structures. +Only a ray tracing feature whose bit is enabled in the feature mask can +get used. +If a feature bit is not set, the behaviour is undefined, thus the +feature may work or not. +To enable multiple features the respective features have to get combined +using a bitwise \f[C]OR\f[R] operation. +.PP +The purpose of feature flags is to reduce code size on the GPU by +enabling just the features required to render the scene. +On the CPU there is no need to use feature flags, and the default of all +features enabled (\f[C]RTC_FEATURE_FLAG_ALL\f[R]) can just be kept. +.PP +The following features can get enabled using feature flags: +.IP \[bu] 2 +RTC_FEATURE_FLAG_MOTION_BLUR: Enables motion blur for all geometry +types. +.IP \[bu] 2 +RTC_FEATURE_FLAG_TRIANGLE: Enables triangle geometries +(RTC_GEOMETRY_TYPE_TRIANGLE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_QUAD: Enables quad geometries (RTC_GEOMETRY_TYPE_QUAD). +.IP \[bu] 2 +RTC_FEATURE_FLAG_GRID: Enables grid geometries (RTC_GEOMETRY_TYPE_GRID). +.IP \[bu] 2 +RTC_FEATURE_FLAG_SUBDIVISION: Enables subdivision geometries +(RTC_GEOMETRY_TYPE_SUBDIVISION). +.IP \[bu] 2 +RTC_FEATURE_FLAG_POINT: Enables all point geometry types +(RTC_GEOMETRY_TYPE_XXX_POINT) +.IP \[bu] 2 +RTC_FEATURE_FLAG_CURVES: Enables all curve geometry types +(RTC_GEOMETRY_TYPE_XXX_YYY_CURVE) +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_CURVES: Enables all round curves +(RTC_GEOMETRY_TYPE_ROUND_XXX_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_CURVES: Enables all flat curves +(RTC_GEOMETRY_TYPE_FLAT_XXX_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_NORMAL_ORIENTED_CURVES: Enables all normal oriented +curves (RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_XXX_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_LINEAR_CURVES: Enables all linear curves +(RTC_GEOMETRY_TYPE_XXX_LINEAR_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_BEZIER_CURVES: Enables all B\['e]zier curves +(RTC_GEOMETRY_TYPE_XXX_BEZIER_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_BSPLINE_CURVES: Enables all B-spline curves +(RTC_GEOMETRY_TYPE_XXX_BSPLINE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_HERMITE_CURVES: Enables all Hermite curves +(RTC_GEOMETRY_TYPE_XXX_HERMITE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_CONE_LINEAR_CURVE: Enables cone geometry type +(RTC_GEOMETRY_TYPE_CONE_LINEAR_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_LINEAR_CURVE: Enables round linear curves +(RTC_GEOMETRY_TYPE_ROUND_LINEAR_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_LINEAR_CURVE: Enables flat linear curves +(RTC_GEOMETRY_TYPE_FLAT_LINEAR_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_BEZIER_CURVE: Enables round B\['e]zier curves +(RTC_GEOMETRY_TYPE_ROUND_BEZIER_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_BEZIER_CURVE: Enables flat B\['e]zier curves +(RTC_GEOMETRY_TYPE_FLAT_BEZIER_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_NORMAL_ORIENTED_BEZIER_CURVE: Enables normal oriented +B\['e]zier curves (RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BEZIER_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_BSPLINE_CURVE: Enables round B-spline curves +(RTC_GEOMETRY_TYPE_ROUND_BSPLINE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_BSPLINE_CURVE: Enables flat B-spline curves +(RTC_GEOMETRY_TYPE_FLAT_BSPLINE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_NORMAL_ORIENTED_BSPLINE_CURVE: Enables normal oriented +B-spline curves (RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BSPLINE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_HERMITE_CURVE: Enables round Hermite curves +(RTC_GEOMETRY_TYPE_ROUND_HERMITE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_HERMITE_CURVE: Enables flat Hermite curves +(RTC_GEOMETRY_TYPE_FLAT_HERMITE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_NORMAL_ORIENTED_HERMITE_CURVE: Enables normal oriented +Hermite curves (RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_HERMITE_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ROUND_CATMULL_ROM_CURVE: Enables round Catmull Rom +curves (RTC_GEOMETRY_TYPE_ROUND_CATMULL_ROM_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FLAT_CATMULL_ROM_CURVE: Enables flat Catmull Rom curves +(RTC_GEOMETRY_TYPE_FLAT_CATMULL_ROM_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_NORMAL_ORIENTED_CATMULL_ROM_CURVE: Enables normal +oriented Catmull Rom curves +(RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_CATMULL_ROM_CURVE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_SPHERE_POINT: Enables sphere geometry type +(RTC_GEOMETRY_TYPE_SPHERE_POINT). +.IP \[bu] 2 +RTC_FEATURE_FLAG_DISC_POINT: Enables disc geometry type +(RTC_GEOMETRY_TYPE_DISC_POINT). +.IP \[bu] 2 +RTC_FEATURE_FLAG_ORIENTED_DISC_POINT: Enables oriented disc geometry +types (RTC_GEOMETRY_TYPE_ORIENTED_DISC_POINT). +.IP \[bu] 2 +RTC_FEATURE_FLAG_INSTANCE: Enables instance geometries +(RTC_GEOMETRY_TYPE_INSTANCE). +.IP \[bu] 2 +RTC_FEATURE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS: Enables filter functions +passed through intersect arguments. +.IP \[bu] 2 +RTC_FEATURE_FLAG_FILTER_FUNCTION_IN_GEOMETRY: Enable filter functions +passed through geometry. +.IP \[bu] 2 +RTC_FEATURE_FLAG_FILTER_FUNCTION: Enables filter functions (argument and +geometry version). +.IP \[bu] 2 +RTC_FEATURE_FLAG_USER_GEOMETRY_CALLBACK_IN_ARGUMENTS: Enables +RTC_GEOMETRY_TYPE_USER with function pointer passed through intersect +arguments. +.IP \[bu] 2 +RTC_FEATURE_FLAG_USER_GEOMETRY_CALLBACK_IN_GEOMETRY: Enables +RTC_GEOMETRY_TYPE_USER with function pointer passed through geometry +object. +.IP \[bu] 2 +RTC_FEATURE_FLAG_USER_GEOMETRY: Enables RTC_GEOMETRY_TYPE_USER +geometries (both argument and geometry callback versions). +.IP \[bu] 2 +RTC_FEATURE_FLAG_32_BIT_RAY_MASK: Enables full 32 bit ray masks. +If not used, only the lower 7 bits in the ray mask are handled +correctly. +.IP \[bu] 2 +RTC_FEATURE_FLAG_ALL: Enables all features (default). +.SS EXIT STATUS +.SS SEE ALSO +.PP +[rtcIntersect1], [rtcIntersect4/8/16], [rtcOccluded1], +[rtcOccluded4/8/16], diff --git a/man/man3/rtcForwardIntersect1.4embree4 b/man/man3/rtcForwardIntersect1.4embree4 new file mode 100644 index 0000000000..72f4fcd4b9 --- /dev/null +++ b/man/man3/rtcForwardIntersect1.4embree4 @@ -0,0 +1,66 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcForwardIntersect1" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcForwardIntersect1 - forwards a single ray to new scene + from user geometry callback +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcForwardIntersect1( + const struct RTCIntersectFunctionNArguments* args, + RTCScene scene, + struct RTCRay* ray, + unsigned int instID +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcForwardIntersect1\f[R] function forwards the traversal of a +transformed ray (\f[C]ray\f[R] argument) into a scene (\f[C]scene\f[R] +argument) from a user geometry callback. +The function can only get invoked from a user geometry callback for a +ray traversal initiated with the \f[C]rtcIntersect1\f[R] function. +The callback arguments structure of the callback invokation has to get +passed to the ray forwarding (\f[C]args\f[R] argument). +The user geometry callback should instantly terminate after invoking the +\f[C]rtcForwardIntersect1\f[R] function. +.PP +Only the ray origin and ray direction members of the ray argument are +used for forwarding, all additional ray properties are inherited from +the initial ray traversal invokation of \f[C]rtcIntersect1\f[R]. +.PP +The implementation of the \f[C]rtcForwardIntersect1\f[R] function +recursively continues the ray traversal into the specified scene and +pushes the provided instance ID (\f[C]instID\f[R] argument) to the +instance ID stack. +Hit information is updated into the ray hit structure passed to the +original \f[C]rtcIntersect1\f[R] invokation. +.PP +This function can get used to implement user defined instancing using +user geometries, e.g.\ by transforming the ray in a special way, and/or +selecting between different scenes to instantiate. +.PP +When using Embree on the CPU it is possible to recursively invoke +\f[C]rtcIntersect1\f[R] directly from a user geometry callback. +However, when SYCL is used, recursively tracing rays is not directly +supported, and the \f[C]rtcForwardIntersect1\f[R] function must be used. +.PP +The ray structure must be aligned to 16 bytes. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcIntersect1], [RTCRay] diff --git a/man/man3/rtcForwardIntersect4.4embree4 b/man/man3/rtcForwardIntersect4.4embree4 new file mode 100644 index 0000000000..f17fb4f714 --- /dev/null +++ b/man/man3/rtcForwardIntersect4.4embree4 @@ -0,0 +1,87 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcForwardIntersect4/8/16" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcForwardIntersect4/8/16 - forwards a ray packet to new scene + from user geometry callback +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcForwardIntersect4( + void int* valid, + const struct RTCIntersectFunctionNArguments* args, + RTCScene scene, + struct RTCRay4* ray, + unsigned int instID +); + +void rtcForwardIntersect4( + void int* valid, + const struct RTCIntersectFunctionNArguments* args, + RTCScene scene, + struct RTCRay4* ray, + unsigned int instID +); + +void rtcForwardIntersect16( + void int* valid, + const struct RTCIntersectFunctionNArguments* args, + RTCScene scene, + struct RTCRay16* ray, + unsigned int instID +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcForwardIntersect4/8/16\f[R] functions forward the traversal +of a transformed ray packet (\f[C]ray\f[R] argument) into a scene +(\f[C]scene\f[R] argument) from a user geometry callback. +The function can only get invoked from a user geometry callback for a +ray traversal initiated with the \f[C]rtcIntersect4/8/16\f[R] function. +The callback arguments structure of the callback invokation has to get +passed to the ray forwarding (\f[C]args\f[R] argument). +The user geometry callback should instantly terminate after invoking the +\f[C]rtcForwardIntersect4/8/16\f[R] function. +.PP +Only the ray origin and ray direction members of the ray argument are +used for forwarding, all additional ray properties are inherited from +the initial ray traversal invokation of \f[C]rtcIntersect4/8/16\f[R]. +.PP +The implementation of the \f[C]rtcForwardIntersect4/8/16\f[R] function +recursively continues the ray traversal into the specified scene and +pushes the provided instance ID (\f[C]instID\f[R] argument) to the +instance ID stack. +Hit information is updated into the ray hit structure passed to the +original \f[C]rtcIntersect4/8/16\f[R] invokation. +.PP +This function can get used to implement user defined instancing using +user geometries, e.g.\ by transforming the ray in a special way, and/or +selecting between different scenes to instantiate. +.PP +When using Embree on the CPU it is possible to recursively invoke +\f[C]rtcIntersect4/8/16\f[R] directly from a user geometry callback. +However, when SYCL is used, recursively tracing rays is not directly +supported, and the \f[C]rtcForwardIntersect4/8/16\f[R] function must be +used. +.PP +For \f[C]rtcForwardIntersect4\f[R] the ray packet must be aligned to 16 +bytes, for \f[C]rtcForwardIntersect8\f[R] the alignment must be 32 +bytes, and for \f[C]rtcForwardIntersect16\f[R] the alignment must be 64 +bytes. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcIntersect4/8/16] diff --git a/man/man3/rtcForwardOccluded1.4embree4 b/man/man3/rtcForwardOccluded1.4embree4 new file mode 100644 index 0000000000..9aa917c51f --- /dev/null +++ b/man/man3/rtcForwardOccluded1.4embree4 @@ -0,0 +1,66 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcForwardOccluded1" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcForwardOccluded1 - forwards a single ray to new scene + from user geometry callback +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcForwardOccluded1( + const struct RTCOccludedFunctionNArguments* args, + RTCScene scene, + struct RTCRay* ray, + unsigned int instID +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcForwardOccluded1\f[R] function forwards the traversal of a +transformed ray (\f[C]ray\f[R] argument) into a scene (\f[C]scene\f[R] +argument) from a user geometry callback. +The function can only get invoked from a user geometry callback for a +ray traversal initiated with the \f[C]rtcOccluded1\f[R] function. +The callback arguments structure of the callback invokation has to get +passed to the ray forwarding (\f[C]args\f[R] argument). +The user geometry callback should instantly terminate after invoking the +\f[C]rtcForwardOccluded1\f[R] function. +.PP +Only the ray origin and ray direction members of the ray argument are +used for forwarding, all additional ray properties are inherited from +the initial ray traversal invokation of \f[C]rtcOccluded1\f[R]. +.PP +The implementation of the \f[C]rtcForwardOccluded1\f[R] function +recursively continues the ray traversal into the specified scene and +pushes the provided instance ID (\f[C]instID\f[R] argument) to the +instance ID stack. +Hit information is updated into the ray structure passed to the original +\f[C]rtcOccluded1\f[R] invokation. +.PP +This function can get used to implement user defined instancing using +user geometries, e.g.\ by transforming the ray in a special way, and/or +selecting between different scenes to instantiate. +.PP +When using Embree on the CPU it is possible to recursively invoke +\f[C]rtcOccluded1\f[R] directly from a user geometry callback. +However, when SYCL is used, recursively tracing rays is not directly +supported, and the \f[C]rtcForwardOccluded1\f[R] function must be used. +.PP +The ray structure must be aligned to 16 bytes. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcOccluded1], [RTCRay] diff --git a/man/man3/rtcForwardOccluded4.4embree4 b/man/man3/rtcForwardOccluded4.4embree4 new file mode 100644 index 0000000000..542314905c --- /dev/null +++ b/man/man3/rtcForwardOccluded4.4embree4 @@ -0,0 +1,86 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcForwardOccluded4/8/16" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcForwardOccluded4/8/16 - forwards a ray packet to new scene + from user geometry callback +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcForwardOccluded4( + void int* valid, + const struct RTCOccludedFunctionNArguments* args, + RTCScene scene, + struct RTCRay4* ray, + unsigned int instID +); + +void rtcForwardOccluded4( + void int* valid, + const struct RTCOccludedFunctionNArguments* args, + RTCScene scene, + struct RTCRay4* ray, + unsigned int instID +); + +void rtcForwardOccluded16( + void int* valid, + const struct RTCOccludedFunctionNArguments* args, + RTCScene scene, + struct RTCRay16* ray, + unsigned int instID +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcForwardOccluded4/8/16\f[R] functions forward the traversal +of a transformed ray packet (\f[C]ray\f[R] argument) into a scene +(\f[C]scene\f[R] argument) from a user geometry callback. +The function can only get invoked from a user geometry callback for a +ray traversal initiated with the \f[C]rtcOccluded4/8/16\f[R] function. +The callback arguments structure of the callback invokation has to get +passed to the ray forwarding (\f[C]args\f[R] argument). +The user geometry callback should instantly terminate after invoking the +\f[C]rtcForwardOccluded4/8/16\f[R] function. +.PP +Only the ray origin and ray direction members of the ray argument are +used for forwarding, all additional ray properties are inherited from +the initial ray traversal invokation of \f[C]rtcOccluded4/8/16\f[R]. +.PP +The implementation of the \f[C]rtcForwardOccluded4/8/16\f[R] function +recursively continues the ray traversal into the specified scene and +pushes the provided instance ID (\f[C]instID\f[R] argument) to the +instance ID stack. +Hit information is updated into the ray structure passed to the original +\f[C]rtcOccluded4/8/16\f[R] invokation. +.PP +This function can get used to implement user defined instancing using +user geometries, e.g.\ by transforming the ray in a special way, and/or +selecting between different scenes to instantiate. +.PP +When using Embree on the CPU it is possible to recursively invoke +\f[C]rtcOccluded4/8/16\f[R] directly from a user geometry callback. +However, when SYCL is used, recursively tracing rays is not directly +supported, and the \f[C]rtcForwardOccluded4/8/16\f[R] function must be +used. +.PP +For \f[C]rtcForwardOccluded4\f[R] the ray packet must be aligned to 16 +bytes, for \f[C]rtcForwardOccluded8\f[R] the alignment must be 32 bytes, +and for \f[C]rtcForwardOccluded16\f[R] the alignment must be 64 bytes. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcOccluded4/8/16] diff --git a/man/man3/rtcGetDeviceProperty.4embree4 b/man/man3/rtcGetDeviceProperty.4embree4 index fb9a583431..c9b5a5c413 100644 --- a/man/man3/rtcGetDeviceProperty.4embree4 +++ b/man/man3/rtcGetDeviceProperty.4embree4 @@ -77,6 +77,16 @@ back face culling is enabled. This is only the case if Embree is compiled with \f[C]EMBREE_BACKFACE_CULLING\f[R] enabled. .IP \[bu] 2 +\f[C]RTC_DEVICE_PROPERTY_BACKFACE_CULLING_CURVES_ENABLED\f[R]: Queries +whether back face culling for curves is enabled. +This is only the case if Embree is compiled with +\f[C]EMBREE_BACKFACE_CULLING_CURVES\f[R] enabled. +.IP \[bu] 2 +\f[C]RTC_DEVICE_PROPERTY_BACKFACE_CULLING_SPHERES_ENABLED\f[R]: Queries +whether back face culling for spheres is enabled. +This is only the case if Embree is compiled with +\f[C]EMBREE_BACKFACE_CULLING_SPHERES\f[R] enabled. +.IP \[bu] 2 \f[C]RTC_DEVICE_PROPERTY_COMPACT_POLYS_ENABLED\f[R]: Queries whether compact polys is enabled. This is only the case if Embree is compiled with diff --git a/man/man3/rtcGetGeometryUserDataFromScene.4embree4 b/man/man3/rtcGetGeometryUserDataFromScene.4embree4 new file mode 100644 index 0000000000..6c80be02da --- /dev/null +++ b/man/man3/rtcGetGeometryUserDataFromScene.4embree4 @@ -0,0 +1,38 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcGetGeometryUserDataFromScene" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcGetGeometryUserDataFromScene - returns the user data pointer + of the geometry through the scene object +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void* rtcGetGeometryUserDataFromScene(RTCScene scene, unsigned int geomID); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcGetGeometryUserDataFromScene\f[R] function queries the user +data pointer previously set with \f[C]rtcSetGeometryUserData\f[R] from +the geometry with index \f[C]geomID\f[R] from the specified scene +\f[C]scene\f[R]. +When \f[C]rtcSetGeometryUserData\f[R] was not called yet, \f[C]NULL\f[R] +is returned. +.PP +This function is supposed to be used during rendering. +.SS EXIT STATUS +.PP +On failure an error code is set that can be queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcSetGeometryUserData], [rtcGetGeometryUserData] diff --git a/man/man3/rtcGetSYCLDeviceFunctionPointer.4embree4 b/man/man3/rtcGetSYCLDeviceFunctionPointer.4embree4 new file mode 100644 index 0000000000..b5c4e8028b --- /dev/null +++ b/man/man3/rtcGetSYCLDeviceFunctionPointer.4embree4 @@ -0,0 +1,59 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcGetSYCLDeviceFunctionPointer" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcGetSYCLDeviceFunctionPointer - obtains a device side + function pointer for some SYCL function +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +template +inline decltype(F) rtcGetSYCLDeviceFunctionPointer(sycl::queue& queue); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function returns a device side function pointer for some function +F. +This function F must be defined using the +\f[C]RTC_SYCL_INDIRECTLY_CALLABLE\f[R] attribute, e.g.: +.IP +.nf +\f[C] +RTC_SYCL_INDIRECTLY_CALLABLE void filter( + const RTCFilterFunctionNArguments* args) { ... } + +RTCFilterFunctionN fptr = rtcGetSYCLDeviceFunctionPointer(queue); +\f[R] +.fi +.PP +Such a device side function pointers of some filter callbacks can get +assigned to a geometry using the +\f[C]rtcSetGeometryIntersectFilterFunction\f[R] and +\f[C]rtcSetGeometryOccludedFilterFunction\f[R] API functions. +.PP +Further, device side function pointers for user geometry callbacks can +be assigned to geometries using the +\f[C]rtcSetGeometryIntersectFunction\f[R] and +\f[C]rtcSetGeometryOccludedFunction\f[R] API calls. +.PP +These geometry versions of the callback functions are disabled in SYCL +by default, and we recommend not using them for performance reasons. +.SS EXIT STATUS +.PP +On failure an error code is set that can be queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcSetGeometryIntersectFunction], [rtcSetGeometryOccludedFunction], +[rtcSetGeometryIntersectFilterFunction], +[rtcSetGeometryOccludedFilterFunction] diff --git a/man/man3/rtcInitIntersectArguments.4embree4 b/man/man3/rtcInitIntersectArguments.4embree4 new file mode 100644 index 0000000000..3813dc44bd --- /dev/null +++ b/man/man3/rtcInitIntersectArguments.4embree4 @@ -0,0 +1,111 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcInitIntersectArguments" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcInitIntersectArguments - initializes the intersect arguments struct +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +enum RTCRayQueryFlags +{ + RTC_RAY_QUERY_FLAG_NONE, + RTC_RAY_QUERY_FLAG_INCOHERENT, + RTC_RAY_QUERY_FLAG_COHERENT, + RTC_RAY_QUERY_FLAG_INVOKE_ARGUMENT_FILTER +}; + +struct RTCIntersectArguments +{ + enum RTCRayQueryFlags flags; + enum RTCFeatureFlags feature_mask; + struct RTCRayQueryContext* context; + RTCFilterFunctionN filter; + RTCIntersectFunctionN intersect; +#if RTC_MIN_WIDTH + float minWidthDistanceFactor; +#endif +}; + +void rtcInitIntersectArguments( + struct RTCIntersectArguments* args +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcInitIntersectArguments\f[R] function initializes the +optional argument struct that can get passed to the +\f[C]rtcIntersect1/4/8/16\f[R] functions to default values. +The arguments struct needs to get used for more advanced Embree features +as described here. +.PP +The \f[C]flags\f[R] member can get used to enable special traversal +mode. +Using the \f[C]RTC_RAY_QUERY_FLAG_INCOHERENT\f[R] flag uses an optimized +traversal algorithm for incoherent rays (default), while +\f[C]RTC_RAY_QUERY_FLAG_COHERENT\f[R] uses an optimized traversal +algorithm for coherent rays (e.g.\ primary camera rays). +.PP +The \f[C]feature_mask\f[R] member should get used in SYCL to just enable +ray tracing features required to render a given scene. +Please see section [RTCFeatureFlags] for a more detailed description. +.PP +The \f[C]context\f[R] member can get used to pass an optional +intersection context. +It is guaranteed that the pointer to the context passed to a ray query +is directly passed to all callback functions. +This way it is possible to attach arbitrary data to the end of the +context, such as a per-ray payload. +Please note that the ray pointer is not guaranteed to be passed to the +callback functions, thus reading additional data from the ray pointer +passed to callbacks is not possible. +See section [rtcInitRayQueryContext] for more details. +.PP +The \f[C]filter\f[R] member specifies a filter function to invoke for +each encountered hit. +The support for the argument filter function must be enabled for a scene +by using the \f[C]RTC_SCENE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS\f[R] scene +flag. +In case of instancing this feature has to get enabled also for each +instantiated scene. +.PP +The argument filter function is invoked for each geometry for which it +got explicitely enabled using the +\f[C]rtcSetGeometryEnableFilterFunctionFromArguments\f[R] function. +The invokation of the argument filter function can also get enfored for +each geometry using the +\f[C]RTC_RAY_QUERY_FLAG_INVOKE_ARGUMENT_FILTER\f[R] ray query flag. +This argument filter function is invoked as a second filter stage after +the per-geometry filter function is invoked. +Only rays that passed the first filter stage are valid in this second +filter stage. +Having such a per ray-query filter function can be useful to implement +modifications of the behavior of the query, such as collecting all hits +or accumulating transparencies. +.PP +The \f[C]intersect\f[R] member specifies the user geometry callback to +get invoked for each user geometry encountered during traversal. +The user geometry callback specified this way has preference over the +one specified inside the geometry. +.PP +The \f[C]minWidthDistanceFactor\f[R] value controls the target size of +the curve radii when the min-width feature is enabled. +Please see the [rtcSetGeometryMaxRadiusScale] function for more details +on the min-width feature. +.SS EXIT STATUS +.PP +No error code is set by this function. +.SS SEE ALSO +.PP +[rtcIntersect1], [rtcIntersect4/8/16], [RTCFeatureFlags], +[rtcInitRayQueryContext], [RTC_GEOMETRY_TYPE_USER], +[rtcSetGeometryMaxRadiusScale] diff --git a/man/man3/rtcInitOccludedArguments.4embree4 b/man/man3/rtcInitOccludedArguments.4embree4 new file mode 100644 index 0000000000..f7539cce00 --- /dev/null +++ b/man/man3/rtcInitOccludedArguments.4embree4 @@ -0,0 +1,111 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcInitOccludedArguments" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcInitOccludedArguments - initializes the occluded arguments struct +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +enum RTCRayQueryFlags +{ + RTC_RAY_QUERY_FLAG_NONE, + RTC_RAY_QUERY_FLAG_INCOHERENT, + RTC_RAY_QUERY_FLAG_COHERENT, + RTC_RAY_QUERY_FLAG_INVOKE_ARGUMENT_FILTER +}; + +struct RTCOccludedArguments +{ + enum RTCRayQueryFlags flags; + enum RTCFeatureFlags feature_mask; + struct RTCRayQueryContext* context; + RTCFilterFunctionN filter; + RTCOccludedFunctionN intersect; +#if RTC_MIN_WIDTH + float minWidthDistanceFactor; +#endif +}; + +void rtcInitOccludedArguments( + struct RTCOccludedArguments* args +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcInitOccludedArguments\f[R] function initializes the optional +argument struct that can get passed to the \f[C]rtcOccluded1/4/8/16\f[R] +functions to default values. +The arguments struct needs to get used for more advanced Embree features +as described here. +.PP +The \f[C]flags\f[R] member can get used to enable special traversal +mode. +Using the \f[C]RTC_RAY_QUERY_FLAG_INCOHERENT\f[R] flag uses an optimized +traversal algorithm for incoherent rays (default), while +\f[C]RTC_RAY_QUERY_FLAG_COHERENT\f[R] uses an optimized traversal +algorithm for coherent rays (e.g.\ primary camera rays). +.PP +The \f[C]feature_mask\f[R] member should get used in SYCL to just enable +ray tracing features required to render a given scene. +Please see section [RTCFeatureFlags] for a more detailed description. +.PP +The \f[C]context\f[R] member can get used to pass an optional +intersection context. +It is guaranteed that the pointer to the context passed to a ray query +is directly passed to all callback functions. +This way it is possible to attach arbitrary data to the end of the +context, such as a per-ray payload. +Please note that the ray pointer is not guaranteed to be passed to the +callback functions, thus reading additional data from the ray pointer +passed to callbacks is not possible. +See section [rtcInitRayQueryContext] for more details. +.PP +The \f[C]filter\f[R] member specifies a filter function to invoked for +each encountered hit. +The support for the argument filter function must be enabled for a scene +by using the \f[C]RTC_SCENE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS\f[R] scene +flag. +In case of instancing this feature has to get enabled also for each +instantiated scene. +.PP +The argument filter function is invoked for each geometry for which it +got explicitely enabled using the +\f[C]rtcSetGeometryEnableFilterFunctionFromArguments\f[R] function. +The invokation of the argument filter function can also get enfored for +each geometry using the +\f[C]RTC_RAY_QUERY_FLAG_INVOKE_ARGUMENT_FILTER\f[R] ray query flag. +This argument filter function is invoked as a second filter stage after +the per-geometry filter function is invoked. +Only rays that passed the first filter stage are valid in this second +filter stage. +Having such a per ray-query filter function can be useful to implement +modifications of the behavior of the query, such as collecting all hits +or accumulating transparencies. +.PP +The \f[C]intersect\f[R] member specifies the user geometry callback to +get invoked for each user geometry encountered during traversal. +The user geometry callback specified this way has preference over the +one specified inside the geometry. +.PP +The \f[C]minWidthDistanceFactor\f[R] value controls the target size of +the curve radii when the min-width feature is enabled. +Please see the [rtcSetGeometryMaxRadiusScale] function for more details +on the min-width feature. +.SS EXIT STATUS +.PP +No error code is set by this function. +.SS SEE ALSO +.PP +[rtcOccluded1], [rtcOccluded4/8/16], [RTCFeatureFlags], +[rtcInitRayQueryContext], [RTC_GEOMETRY_TYPE_USER], +[rtcSetGeometryMaxRadiusScale] diff --git a/man/man3/rtcInvokeIntersectFilterFromGeometry.4embree4 b/man/man3/rtcInvokeIntersectFilterFromGeometry.4embree4 new file mode 100644 index 0000000000..2f9336af05 --- /dev/null +++ b/man/man3/rtcInvokeIntersectFilterFromGeometry.4embree4 @@ -0,0 +1,43 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcInvokeIntersectFilterFromGeometry" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcInvokeIntersectFilterFromGeometry - invokes the + intersection filter function from the geometry +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcInvokeIntersectFilterFromGeometry( + const struct RTCIntersectFunctionNArguments* args, + const struct RTCFilterFunctionNArguments* filterArgs +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcInvokeIntersectFilterFromGeometry\f[R] function can be +called inside an \f[C]RTCIntersectFunctionN\f[R] user geometry callback +function to invoke the intersection filter registered to the geometry. +For this an \f[C]RTCFilterFunctionNArguments\f[R] structure must be +created (see \f[C]rtcSetGeometryIntersectFilterFunction\f[R]) which +basically consists of a valid mask, a hit packet to filter, the +corresponding ray packet, and the packet size. +After the invocation of \f[C]rtcInvokeIntersectFilterFromGeometry\f[R], +only rays that are still valid (valid mask set to -1) should update a +hit. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcInvokeOccludedFilterFromGeometry], [rtcSetGeometryIntersectFunction] diff --git a/man/man3/rtcInvokeOccludedFilterFromGeometry.4embree4 b/man/man3/rtcInvokeOccludedFilterFromGeometry.4embree4 new file mode 100644 index 0000000000..4f4f4b1a7c --- /dev/null +++ b/man/man3/rtcInvokeOccludedFilterFromGeometry.4embree4 @@ -0,0 +1,43 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcInvokeOccludedFilterFromGeometry" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcInvokeOccludedFilterFromGeometry - invokes the occlusion + filter function from the geometry +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcInvokeOccludedFilterFromGeometry( + const struct RTCOccludedFunctionNArguments* args, + const struct RTCFilterFunctionNArguments* filterArgs +); +\f[R] +.fi +.SS DESCRIPTION +.PP +The \f[C]rtcInvokeOccludedFilterFromGeometry\f[R] function can be called +inside an \f[C]RTCOccludedFunctionN\f[R] user geometry callback function +to invoke the occlusion filter registered to the geometry. +For this an \f[C]RTCFilterFunctionNArguments\f[R] structure must be +created (see \f[C]rtcSetGeometryIntersectFilterFunction\f[R]) which +basically consists of a valid mask, a hit packet to filter, the +corresponding ray packet, and the packet size. +After the invocation of \f[C]rtcInvokeOccludedFilterFromGeometry\f[R] +only rays that are still valid (valid mask set to -1) should signal an +occlusion. +.SS EXIT STATUS +.PP +For performance reasons this function does not do any error checks, thus +will not set any error flags on failure. +.SS SEE ALSO +.PP +[rtcInvokeIntersectFilterFromGeometry], [rtcSetGeometryOccludedFunction] diff --git a/man/man3/rtcIsSYCLDeviceSupported.4embree4 b/man/man3/rtcIsSYCLDeviceSupported.4embree4 new file mode 100644 index 0000000000..0fab577ce1 --- /dev/null +++ b/man/man3/rtcIsSYCLDeviceSupported.4embree4 @@ -0,0 +1,33 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcIsSYCLDeviceSupported" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcIsSYCLDeviceSupported - checks if some SYCL device is supported by Embree +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +bool rtcIsSYCLDeviceSupported(const sycl::device sycl_device); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function can be used to check if some SYCL device +(\f[C]sycl_device\f[R] argument) is supported by Embree. +.SS EXIT STATUS +.PP +The function returns true if the SYCL device is supported by Embree and +false otherwise. +On failure an error code is set that can get queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcSYCLDeviceSelector] diff --git a/man/man3/rtcNewSYCLDevice.4embree4 b/man/man3/rtcNewSYCLDevice.4embree4 new file mode 100644 index 0000000000..bfde39b70b --- /dev/null +++ b/man/man3/rtcNewSYCLDevice.4embree4 @@ -0,0 +1,55 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcNewSYCLDevice" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcNewSYCLDevice - creates a new device to be used with SYCL +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +RTCDevice rtcNewSYCLDevice(sycl::context context, const char* config); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function creates a new device to be used with SYCL for GPU +rendering and returns a handle to this device. +The device object is reference counted with an initial reference count +of 1. +The handle can get released using the \f[C]rtcReleaseDevice\f[R] API +call. +.PP +The passed SYCL context (\f[C]context\f[R] argument) is used to allocate +GPU data, thus only devices contained inside this context can be used +for rendering. +By default the GPU data is allocated on the first GPU device of the +context, but this behavior can get changed with the +[rtcSetDeviceSYCLDevice] function. +.PP +The device object acts as a class factory for all other object types. +All objects created from the device (like scenes, geometries, etc.) hold +a reference to the device, thus the device will not be destroyed unless +these objects are destroyed first. +.PP +Objects are only compatible if they belong to the same device, e.g it is +not allowed to create a geometry in one device and attach it to a scene +created with a different device. +.PP +For an overview of configurations that can get passed (\f[C]config\f[R] +argument) please see the [rtcNewDevice] function description. +.SS EXIT STATUS +.PP +On success returns a handle of the created device. +On failure returns \f[C]NULL\f[R] as device and sets a per-thread error +code that can be queried using \f[C]rtcGetDeviceError(NULL)\f[R]. +.SS SEE ALSO +.PP +[rtcRetainDevice], [rtcReleaseDevice], [rtcNewDevice] diff --git a/man/man3/rtcSYCLDeviceSelector.4embree4 b/man/man3/rtcSYCLDeviceSelector.4embree4 new file mode 100644 index 0000000000..20e197ae3d --- /dev/null +++ b/man/man3/rtcSYCLDeviceSelector.4embree4 @@ -0,0 +1,47 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcSYCLDeviceSelector" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcSYCLDeviceSelector - SYCL device selector function to select + devices supported by Embree +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +int rtcSYCLDeviceSelector(const sycl::device sycl_device); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function checks if the passed SYCL device (\f[C]sycl_device\f[R] +arguments) is supported by Embree or not. +This function can be used directly to select some supported SYCL device +by using it as SYCL device selector function. +For instance, the following code sequence selects an Embree supported +SYCL device and creates an Embree device from it: +.IP +.nf +\f[C] +sycl::device sycl_device(rtcSYCLDeviceSelector); +sycl::queue sycl_queue(sycl_device); +sycl::context(sycl_device); +RTCDevice device = rtcNewSYCLDevice(sycl_context,nullptr); +\f[R] +.fi +.SS EXIT STATUS +.PP +The function returns -1 if the SYCL device is supported by Embree and 1 +otherwise. +On failure an error code is set that can get queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcIsSYCLDeviceSupported] diff --git a/man/man3/rtcSetDeviceSYCLDevice.4embree4 b/man/man3/rtcSetDeviceSYCLDevice.4embree4 new file mode 100644 index 0000000000..567269b9da --- /dev/null +++ b/man/man3/rtcSetDeviceSYCLDevice.4embree4 @@ -0,0 +1,34 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcSetDeviceSYCLDevice" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcSetDeviceSYCLDevice - sets the SYCL device to be used for memory allocations +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcSetDeviceSYCLDevice(RTCDevice device, const sycl::device sycl_device); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function sets the SYCL device (\f[C]sycl_device\f[R] argument) to +be used to allocate GPU memory when using the specified Embree device +(\f[C]device\f[R] argument). +This SYCL device must be one of the SYCL devices contained inside the +SYCL context used to create the Embree device. +.SS EXIT STATUS +.PP +On failure an error code is set that can get queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcNewSYCLDevice] diff --git a/man/man3/rtcSetGeometryEnableFilterFunctionFromArguments.4embree4 b/man/man3/rtcSetGeometryEnableFilterFunctionFromArguments.4embree4 new file mode 100644 index 0000000000..7bd70c50b2 --- /dev/null +++ b/man/man3/rtcSetGeometryEnableFilterFunctionFromArguments.4embree4 @@ -0,0 +1,52 @@ +.\" Automatically generated by Pandoc 2.9.2.1 +.\" +.TH "rtcSetGeometryEnableFilterFunctionFromArguments" "3" "" "" "Embree Ray Tracing Kernels 4" +.hy +.SS NAME +.IP +.nf +\f[C] +rtcSetGeometryEnableFilterFunctionFromArguments - enables + argument filter functions for the geometry +\f[R] +.fi +.SS SYNOPSIS +.IP +.nf +\f[C] +#include + +void rtcSetGeometryEnableFilterFunctionFromArguments( + RTCGeometry geometry, bool enable); +\f[R] +.fi +.SS DESCRIPTION +.PP +This function enables invokation the filter function passed through +\f[C]RTCIntersectArguments\f[R] or \f[C]RTCOccludedArguments\f[R] to the +intersect and occluded queries. +If enable is true the argument filter function invokation is enabled for +the geometry or disabled otherwise. +By default the invokation of the argument filter function is disabled +for some geometry. +.PP +The argument filter function invokation can also get enforced for each +geometry by using the +\f[C]RTC_RAY_QUERY_FLAG_INVOKE_ARGUMENT_FILTER\f[R] ray query flag that +can get passed to \f[C]rtcIntersect\f[R] and \f[C]rtcOccluded\f[R] +functions. +See Section [rtcInitIntersectArguments] and [rtcInitOccludedArguments] +for more details. +.PP +In order to use the argument filter function for some scene, that +feature additionally has to get enabled using the +\f[C]RTC_SCENE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS\f[R] scene flag. +See Section [rtcSetSceneFlags] for more details. +.SS EXIT STATUS +.PP +On failure an error code is set that can get queried using +\f[C]rtcGetDeviceError\f[R]. +.SS SEE ALSO +.PP +[rtcInitIntersectArguments], [rtcInitOccludedArguments], +[rtcSetSceneFlags] diff --git a/readme.pdf b/readme.pdf index 9f8dce6523..35d36beeae 100644 Binary files a/readme.pdf and b/readme.pdf differ