diff --git a/CHANGELOG.md b/CHANGELOG.md index d4e4cab3d..831a350b3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,17 +3,6 @@ Version History ### Changes in v3.2.0: -- Clarify the size of `OSP_BOOL` to be 1 byte -- Support half-precision (16\ bit float) texture formats - `OSP_TEXTURE_[RGBA16F|RGB16F|RA16F|R16F]` and two-channel 32\ bit - float textures `OSP_TEXTURE_RA32F` -- Implement MIP Mapping for better texture filtering. If the - additional memory per texture needed cannot be spared, applications - can disable the generation of MIP maps with device parameter - `disableMipMapGeneration` -- New parameter `limitIndirectLightSamples` for the `pathtracer` which - limits the number of light samples after the first non-specular - (i.e., diffuse and glossy) bounce to at most one - Sampling improvements: - Better performance (lower rendering time and faster convergence) - More pleasing blue noise enabled when the total number of frames @@ -24,18 +13,32 @@ Version History - User-controlled quality levels via parameter `quality` - Optionally denoise alpha channel as well, enabled via parameter `denoiseAlpha` +- Support half-precision (16\ bit float) texture formats + `OSP_TEXTURE_[RGBA16F|RGB16F|RA16F|R16F]` and two-channel 32\ bit + float textures `OSP_TEXTURE_RA32F` +- New parameter `limitIndirectLightSamples` for the `pathtracer` which + limits the number of light samples after the first non-specular + (i.e., diffuse and glossy) bounce to at most one +- Implement MIP Mapping for better texture filtering. If the + additional memory per texture needed cannot be spared, applications + can disable the generation of MIP maps with device parameter + `disableMipMapGeneration` +- The backplate (background texture) is now always sampled at the pixel + center and thus not blurred by the pixel filter anymore +- Avoid color bleeding across eye-subimages when stereo rendering +- Superbuild uses binary packages of Open VKL - Removed Intel ISPCRT dependency (ISPC compiler is still needed): - oneAPI Level Zero Loader is no longer necessary - `zeContext` and `zeDevice`device parameters are no longer supported - `ispcrtContext` and `ispcrtDevice`device parameters are no longer supported -- Superbuild uses binary packages of Open VKL -- Avoid color bleeding across eye-subimages when stereo rendering -- The backplate (background texture) is now always sampled at the pixel - center and thus not blurred by the pixel filter anymore -- Fix artifacts occassionally appearing with `gpu` device +- Clarify the size of `OSP_BOOL` to be 1 byte +- Fix artifacts occasionally appearing with `gpu` device - The new minimum versions of dependencies: - Embree v4.3.3 (better error reporting) + - Open Image Denoise v2.3 (better image quality with `HIGH` + quality mode, added `FAST` quality mode) + - rkcommon v1.14.0 ### Changes in v3.1.0: diff --git a/README.md b/README.md index 426defee6..4cd1eef48 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,9 @@ OSPRay ====== -This is release v3.2.0 (devel) of Intel® OSPRay. For changes and new -features see the [changelog](CHANGELOG.md). Visit http://www.ospray.org -for more information. +This is release v3.2.0 of Intel® OSPRay. For changes and new features +see the [changelog](CHANGELOG.md). Visit http://www.ospray.org for more +information. OSPRay Overview =============== @@ -11,8 +11,8 @@ OSPRay Overview Intel® OSPRay is an **o**pen source, **s**calable, and **p**ortable **ray** tracing engine for high-performance, high-fidelity visualization on Intel Architecture CPUs, Intel Xe GPUs, and ARM64 CPUs. OSPRay is -part of the [Intel oneAPI Rendering -Toolkit](https://software.intel.com/en-us/rendering-framework) and is +part of the [Intel Rendering Toolkit (Render +Kit)](https://software.intel.com/en-us/rendering-framework) and is released under the permissive [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0). @@ -99,7 +99,7 @@ before you can build OSPRay you need the following prerequisites: `Internal`. - OSPRay also heavily uses Intel [Embree](https://www.embree.org/), - installing version 4.3.1 or newer is required. If Embree is not found + installing version 4.3.3 or newer is required. If Embree is not found by CMake its location can be hinted with the variable `embree_DIR`. - OSPRay supports volume rendering (enabled by default via @@ -111,7 +111,7 @@ before you can build OSPRay you need the following prerequisites: - OSPRay also provides an optional module implementing the `denoiser` image operation, which is enabled by `OSPRAY_MODULE_DENOISER`. This module requires Intel [Open Image - Denoise](https://openimagedenoise.github.io/) in version 2.2.0 or + Denoise](https://openimagedenoise.github.io/) in version 2.3.0 or newer. You may need to hint the location of the library with the CMake variable `OpenImageDenoise_DIR`. @@ -182,7 +182,7 @@ cmake [/scripts/superbuild] cmake --build . ``` -On Windows make sure to select a 64bit generator, e.g. +On Windows make sure to select a 64 bit generator, e.g. ``` sh cmake -G "Visual Studio 17 2022" [/scripts/superbuild] @@ -412,9 +412,9 @@ Documentation ============= The following [API -documentation](https://www.ospray.org/OSPRay_readme_devel.pdf "OSPRay Documentation") +documentation](https://www.ospray.org/OSPRay_readme.pdf "OSPRay Documentation") of OSPRay can also be found as a [pdf -document](https://www.ospray.org/OSPRay_readme_devel.pdf "OSPRay Documentation"). +document](https://www.ospray.org/OSPRay_readme.pdf "OSPRay Documentation"). For a deeper explanation of the concepts, design, features and performance of OSPRay also have a look at the IEEE Vis 2016 paper @@ -508,15 +508,16 @@ exactly the same as `ospSetParam`, which is documented below in the [parameters](#parameters) section. The following parameters can be set on all devices: -| Type | Name | Description | -|:-------|:------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| int | numThreads | number of threads which OSPRay should use | -| uint | logLevel | logging level; valid values (in order of severity) are `OSP_LOG_NONE`, `OSP_LOG_ERROR`, `OSP_LOG_WARNING`, `OSP_LOG_INFO`, and `OSP_LOG_DEBUG` | -| string | logOutput | convenience for setting where status messages go; valid values are `cerr` and `cout` | -| string | errorOutput | convenience for setting where error messages go; valid values are `cerr` and `cout` | -| bool | debug | set debug mode; equivalent to `logLevel=debug` and `numThreads=1` | -| bool | warnAsError | send `warning` and `error` messages through the error callback, otherwise send `warning` messages through the message callback; must have sufficient `logLevel` to enable warnings | -| bool | setAffinity | bind software threads to hardware threads if set to 1; 0 disables binding omitting the parameter will let OSPRay choose | +| Type | Name | Description | +|:-------|:------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| int | numThreads | number of threads which OSPRay should use | +| bool | disableMipMapGeneration | disable the default generation of MIP maps for textures (e.g., to save the additional memory needed) | +| uint | logLevel | logging level; valid values (in order of severity) are `OSP_LOG_NONE`, `OSP_LOG_ERROR`, `OSP_LOG_WARNING`, `OSP_LOG_INFO`, and `OSP_LOG_DEBUG` | +| string | logOutput | convenience for setting where status messages go; valid values are `cerr` and `cout` | +| string | errorOutput | convenience for setting where error messages go; valid values are `cerr` and `cout` | +| bool | debug | set debug mode; equivalent to `logLevel=debug` and `numThreads=1` | +| bool | warnAsError | send `warning` and `error` messages through the error callback, otherwise send `warning` messages through the message callback; must have sufficient `logLevel` to enable warnings | +| bool | setAffinity | bind software threads to hardware threads if set to 1; 0 disables binding omitting the parameter will let OSPRay choose | Parameters shared by all devices. @@ -873,16 +874,22 @@ below. | OSP_OBJECT | generic object reference | | OSP_CAMERA | camera object reference | | OSP_FRAMEBUFFER | framebuffer object reference | +| OSP_FUTURE | future object reference | | OSP_LIGHT | light object reference | | OSP_MATERIAL | material object reference | | OSP_TEXTURE | texture object reference | | OSP_RENDERER | renderer object reference | | OSP_WORLD | world object reference | +| OSP_GROUP | group object reference | +| OSP_INSTANCE | instance object reference | | OSP_GEOMETRY | geometry object reference | +| OSP_GEOMETRIC_MODEL | geometric model object reference | | OSP_VOLUME | volume object reference | +| OSP_VOLUMETRIC_MODEL | volumetric model object reference | | OSP_TRANSFER_FUNCTION | transfer function object reference | | OSP_IMAGE_OPERATION | image operation object reference | | OSP_STRING | C-style zero-terminated character string | +| OSP_BOOL | 8 bit boolean | | OSP_CHAR, OSP_VEC\[234\]C | 8 bit signed character scalar and \[234\]-element vector | | OSP_UCHAR, OSP_VEC\[234\]UC | 8 bit unsigned character scalar and \[234\]-element vector | | OSP_SHORT, OSP_VEC\[234\]S | 16 bit unsigned integer scalar and \[234\]-element vector | @@ -1172,7 +1179,7 @@ the `cell.type` parameter must be omitted). | bool | indexPrefixed | false | indicates that the `index` array is compatible to VTK, where the indices of each cell are prefixed with the number of vertices | | uint32\[\] / uint64\[\] | cell.index | | [data](#data) array of locations (into the index array), specifying the first index of each cell | | float\[\] | cell.data | | [data](#data) array of cell data values to be sampled | -| uint8\[\] | cell.type | | [data](#data) array of cell types (VTK compatible), only set if `indexPrefixed = false` false. Supported types are: | +| uint8\[\] | cell.type | | [data](#data) array of cell types (VTK compatible), only set if `indexPrefixed = false`. Supported types are: | | | | | `OSP_TETRAHEDRON` | | | | | `OSP_HEXAHEDRON` | | | | | `OSP_WEDGE` | @@ -1394,6 +1401,17 @@ i.e., each four subsequent vertices form one quad. If the size of the `vertex.position` array is not a multiple of three for triangles or four for quads, the remainder vertices are ignored. +Face-varying attributes (`normal`, `motion.normal`, `color`, `texcoord`) +map unique values to each vertex of a primitive/face (triangle or quad), +thus attributes can be different for the same vertex that is shared by +multiple primitives. Essentially, face-varying attributes are a +‘attribute soup’ and behave similar to the implicit index, the size of +the array must be at least three times the number of triangles or four +times the number of quads, respectively. Face-varying attributes take +precedence over the respective vertex attributes (`vertex.normal`, +`motion.vertex.normal`, `vertex.color`, `vertex.texcoord`) when both +arrays of the same attribute are present. + ### Subdivision A mesh consisting of subdivision surfaces, created by specifying a @@ -2367,7 +2385,7 @@ because it is always `OSP_INTENSITY_QUANTITY_RADIANCE`). |:------|:-------------|--------:|:----------------------------------------| | vec3f | color | white | color of the emitted light (linear RGB) | | float | intensity | 1 | intensity of the light (a factor) | -| float | transparency | 1 | material transparency | +| float | transparency | 0 | material transparency | Parameters accepted by the Luminous material. @@ -2421,14 +2439,19 @@ The supported texture formats for `texture2d` are: | OSP_TEXTURE_RGBA8 | 8 bit \[0–255\] linear components red, green, blue, alpha | | OSP_TEXTURE_SRGBA | 8 bit sRGB gamma encoded color components, and linear alpha | | OSP_TEXTURE_RGBA32F | 32 bit float components red, green, blue, alpha | +| OSP_TEXTURE_RGBA16F | 16 bit float components red, green, blue, alpha | | OSP_TEXTURE_RGB8 | 8 bit \[0–255\] linear components red, green, blue | | OSP_TEXTURE_SRGB | 8 bit sRGB gamma encoded components red, green, blue | | OSP_TEXTURE_RGB32F | 32 bit float components red, green, blue | +| OSP_TEXTURE_RGB16F | 16 bit float components red, green, blue | | OSP_TEXTURE_R8 | 8 bit \[0–255\] linear single component red | | OSP_TEXTURE_RA8 | 8 bit \[0–255\] linear two components red, alpha | | OSP_TEXTURE_L8 | 8 bit \[0–255\] gamma encoded luminance (replicated into red, green, blue) | | OSP_TEXTURE_LA8 | 8 bit \[0–255\] gamma encoded luminance, and linear alpha | +| OSP_TEXTURE_RA32F | 32 bit float two component red, alpha | | OSP_TEXTURE_R32F | 32 bit float single component red | +| OSP_TEXTURE_RA16F | 16 bit float two component red, alpha | +| OSP_TEXTURE_R16F | 16 bit float single component red | | OSP_TEXTURE_RGBA16 | 16 bit \[0–65535\] linear components red, green, blue, alpha | | OSP_TEXTURE_RGB16 | 16 bit \[0–65535\] linear components red, green, blue | | OSP_TEXTURE_RA16 | 16 bit \[0–65535\] linear two components red, alpha | @@ -2825,7 +2848,7 @@ General parameters of all renderers are | Type | Name | Default | Description | |:----------------------|:------------------|------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------------| -| int | pixelSamples | 1 | samples per pixel | +| int | pixelSamples | 1 | samples per pixel, best results when a power of 2 | | int | maxPathLength | 20 | maximum ray recursion depth | | float | minContribution | 0.001 | sample contributions below this value will be neglected to speedup rendering | | float | varianceThreshold | 0 | threshold for adaptive accumulation | @@ -2834,6 +2857,7 @@ General parameters of all renderers are | OSPTexture | map_maxDepth | | optional screen-sized float [texture](#texture) with maximum far distance per pixel (use texture type `texture2d`) | | OSPMaterial\[\] | material | | optional [data](#data) array of [materials](#materials) which can be indexed by a [GeometricModel](#geometricmodels)’s `material` parameter | | uint | pixelFilter | `OSP_PIXELFILTER_GAUSS` | `OSPPixelFilterType` to select the pixel filter used by the renderer for antialiasing. Possible pixel filters are listed below. | +| float | mipMapBias | 0 | bias for texture MIP-mapping, balancing between sharpness/aliasing and blurriness due to prefiltering | Parameters understood by all renderers. @@ -2846,7 +2870,8 @@ variance below the `varianceThreshold`. This feature requires a Per default the background of the rendered image will be transparent black, i.e., the alpha channel holds the opacity of the rendered objects. This eases transparency-aware blending of the image with an -arbitrary background image by the application. The parameter +arbitrary background image by the application (via +$ospray.rgb + appBackground.rgb⋅(1-ospray.alpha)$). The parameter `backgroundColor` or `map_backplate` can be used to already blend with a constant background color or backplate texture, respectively, (and alpha) during rendering. @@ -2860,7 +2885,7 @@ distance of primary rays, thus objects of other renderers can hide objects rendered by OSPRay. OSPRay supports antialiasing in image space by using pixel filters, -which are centered around the center of a pixel. The size $w×w$ of the +which are aligned around the center of a pixel. The size $w×w$ of the filter depends on the selected filter type. The types of supported pixel filters are defined by the `OSPPixelFilterType` enum and can be set using the `pixelFilter` parameter. @@ -2875,6 +2900,15 @@ using the `pixelFilter` parameter. Pixel filter types supported by OSPRay for antialiasing in image space. +OSPRay also antialiases textures with prefiltering and MIP-mapping, +which can be adjusted with parameter `mipMapBias`. For final frame +rendering with a high number of `pixelSamples` or accumulated frames +`mipMapBias` can be lowered (e.g., set to -0.5 or -2) to result in +sharper textures which are essentially anisotropically filtered. +Conversely, for preview rendering with just a single sample per pixel a +higher `mipMapBias` of 1 or 2 can reduce texture aliasing and increase +rendering speed. + ### SciVis Renderer The SciVis renderer is a fast ray tracer for scientific visualization @@ -2926,13 +2960,14 @@ realistic materials. This renderer is created by passing the type string parameters](#renderer) understood by all renderers the path tracer supports the following special parameters: -| Type | Name | Default | Description | -|:------|:---------------------|--------:|:------------------------------------------------------------------------------------------| -| int | lightSamples | all | number of random light samples per path vertex, per default all light sources are sampled | -| int | roulettePathLength | 5 | ray recursion depth at which to start Russian roulette termination | -| int | maxScatteringEvents | 20 | maximum number of non-specular (i.e., diffuse and glossy) bounces | -| float | maxContribution | ∞ | samples are clamped to this value before they are accumulated into the framebuffer | -| bool | backgroundRefraction | false | allow for alpha blending even if background is seen through refractive objects like glass | +| Type | Name | Default | Description | +|:------|:--------------------------|--------:|:------------------------------------------------------------------------------------------------------------------------------------------| +| int | lightSamples | all | number of random light samples per path vertex, best results when a power of 2; per default all light sources are sampled | +| bool | limitIndirectLightSamples | true | after the first non-specular (i.e., diffuse and glossy) path vertex take (at most) a single light sample (instead of `lightSamples` many) | +| int | roulettePathLength | 5 | ray recursion depth at which to start Russian roulette termination | +| int | maxScatteringEvents | 20 | maximum number of non-specular (i.e., diffuse and glossy) bounces | +| float | maxContribution | ∞ | samples are clamped to this value before they are accumulated into the framebuffer | +| bool | backgroundRefraction | false | allow for alpha blending even if background is seen through refractive objects like glass | Special parameters understood by the path tracer. @@ -2984,7 +3019,7 @@ values of `OSPFrameBufferChannel` listed in the table below. | OSP_FB_ACCUM | accumulation buffer for progressive refinement | | OSP_FB_VARIANCE | for estimation of the current noise level if OSP_FB_ACCUM is also present, see [rendering](#rendering) | | OSP_FB_NORMAL | accumulated world-space normal of the first non-specular hit, as vec3f | -| OSP_FB_ALBEDO | accumulated material albedo (color without illumination) at the first hit, as vec3f | +| OSP_FB_ALBEDO | accumulated material albedo (color without illumination) at the first non-specular hit, as vec3f | | OSP_FB_ID_PRIMITIVE | primitive index of the first hit, as uint32 | | OSP_FB_ID_OBJECT | geometric/volumetric model `id`, if specified, or index in [group](#groups) of first hit, as uint32 | | OSP_FB_ID_INSTANCE | user defined [instance](#instances) `id`, if specified, or instance index of first hit, as uint32 | @@ -3059,12 +3094,18 @@ The framebuffer takes a list of pixel operations to be applied to the image in sequence as an `OSPData`. The pixel operations will be run in the order they are in the array. -| Type | Name | Description | -|:----------------------|:---------------|:-------------------------------------| -| OSPImageOperation\[\] | imageOperation | ordered sequence of image operations | +| Type | Name | Description | +|:----------------------|:---------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| OSPImageOperation\[\] | imageOperation | ordered sequence of image operations | +| int | targetFrames | anticipated number of frames that will be accumulated for progressive refinement, used renderers to generate a blue noise sampling pattern; should be a power of 2, is always 1 without `OSP_FB_ACCUM`; default 0 (disabled) | Parameters accepted by the framebuffer. +If the total number of frames to be accumulated is known, then +`targetFrames` should be set, because then renderers can generate more +pleasing blue noise patterns. Accumulation stops when `targetFrames` is +reached. + ### Image Operation Image operations are functions that are applied to every pixel of a @@ -3085,32 +3126,20 @@ passing the type string “`tonemapper`” to `ospNewImageOperation`. The tone mapping curve can be customized using the parameters listed in the table below. -| Type | Name | Default | Description | -|:------|:----------|--------:|:-------------------------------------------------------------------------| -| float | exposure | 1.0 | amount of light per unit area | -| float | contrast | 1.6773 | contrast (toe of the curve); typically is in \[1–2\] | -| float | shoulder | 0.9714 | highlight compression (shoulder of the curve); typically is in \[0.9–1\] | -| float | midIn | 0.18 | mid-level anchor input; default is 18% gray | -| float | midOut | 0.18 | mid-level anchor output; default is 18% gray | -| float | hdrMax | 11.0785 | maximum HDR input that is not clipped | -| bool | acesColor | true | apply the ACES color transforms | - -Parameters accepted by the tone mapper. - -To use the popular “Uncharted 2” filmic tone mapping curve instead, set -the parameters to the values listed in the table below. - -| Name | Value | -|:----------|:-------| -| contrast | 1.1759 | -| shoulder | 0.9746 | -| midIn | 0.18 | -| midOut | 0.18 | -| hdrMax | 6.3704 | -| acesColor | false | - -Filmic tone mapping curve parameters. Note that the curve includes an -exposure bias to match 18% middle gray. +| Type | Name | Default | Filmic | Description | +|:------|:----------|--------:|-------:|:-------------------------------------------------------------------------| +| float | exposure | 1.0 | 1.0 | amount of light per unit area | +| float | contrast | 1.6773 | 1.1759 | contrast (toe of the curve); typically is in \[1–2\] | +| float | shoulder | 0.9714 | 0.9746 | highlight compression (shoulder of the curve); typically is in \[0.9–1\] | +| float | midIn | 0.18 | 0.18 | mid-level anchor input; default is 18% gray | +| float | midOut | 0.18 | 0.18 | mid-level anchor output; default is 18% gray | +| float | hdrMax | 11.0785 | 6.3704 | maximum HDR input that is not clipped | +| bool | acesColor | true | false | apply the ACES color transforms | + +Parameters accepted by the tone mapper. The column “Filmic” lists +alternative values for the popular “Uncharted 2” tone mapping curve +(note that that curve includes an exposure bias to match 18% middle +gray). #### Denoiser @@ -3123,6 +3152,16 @@ using a GPU when available. The device selection be overridden by the environment variable `OIDN_DEFAULT_DEVICE`, possible values are `cpu`, `sycl`, `cuda`, `hip`, or a physical device ID +| Type | Name | Description | +|:-----|:-------------|:-------------------------------------------------------------------------------------------------------------------| +| uint | quality | `OSPDenoiserQuality` for denoiser quality, default is | +| | | `OSP_DENOISER_QUALITY_MEDIUM`: balanced quality/performance for interactive/real-time rendering; also allowed are: | +| | | `OSP_DENOISER_QUALITY_LOW`: high performance, for interactive/real-time preview rendering | +| | | `OSP_DENOISER_QUALITY_HIGH`: high quality, for final frame rendering | +| bool | denoiseAlpha | whether to denoise the alpha channel as well, default false | + +Parameters accepted by the denoiser. + Rendering --------- @@ -3134,7 +3173,8 @@ combining a framebuffer, renderer, camera, and world. What to render and how to render it depends on the renderer’s parameters. If the framebuffer supports accumulation (i.e., it was created with `OSP_FB_ACCUM`) then successive calls to `ospRenderFrame` -will progressively refine the rendered image. +will progressively refine the rendered image (until `targetFrames` is +reached). To start an render task, use @@ -3297,20 +3337,20 @@ ospDeviceCommit(dev); ospSetCurrentDevice(dev); ``` -| Type | Name | Description | -|:--------|:------------|:-------------------| -| void \* | syclContext | SYCL context | -| void \* | syclDevice | SYCL device | +| Type | Name | Description | +|:--------|:------------|:-------------| +| void \* | syclContext | SYCL context | +| void \* | syclDevice | SYCL device | Parameters specific to the `gpu` device. Applications can set their SYCL context and device to share device -memory with OSPRay or to control which device should be used -(e.g., in case multiple GPUs are present). If neither parameter is set, -the `gpu` device will automatically create a context internally -and select a GPU (that selection can be influenced via environment -variable `ONEAPI_DEVICE_SELECTOR`, see [Intel oneAPI DPC++ Compiler documentation] -(https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector)). +memory with OSPRay or to control which device should be used (e.g., in +case multiple GPUs are present). If neither parameter is set, the `gpu` +device will automatically create a context internally and select a GPU +(that selection can be influenced via environment variable +`ONEAPI_DEVICE_SELECTOR`, see [Intel oneAPI DPC++ Compiler +documentation](https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector)). Compile times for just in time compilation (JIT compilation) can be large. To resolve this issue we recommend enabling persistent JIT @@ -3322,9 +3362,9 @@ JIT cache should get stored). To reduce GPU memory allocation overhead when rendering scenes with many objects (geometries, instances, etc.), memory pooling should be enabled by setting the environment variable -`SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR="1;0;shared:1M,0,2M"`. -See [Intel oneAPI DPC++ Compiler documentation] -(https://intel.github.io/llvm-docs/EnvironmentVariables.html#debugging-variables-for-level-zero-plugin) +`SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR="1;0;shared:1M,0,2M"`. See [Intel +oneAPI DPC++ Compiler +documentation](https://intel.github.io/llvm-docs/EnvironmentVariables.html#debugging-variables-for-level-zero-plugin) for more details. ### Known Issues diff --git a/STYLEGUIDE.md b/STYLEGUIDE.md index 1c56c67e3..6c8511c13 100644 --- a/STYLEGUIDE.md +++ b/STYLEGUIDE.md @@ -7,7 +7,7 @@ be overly strict. However, deviations from this document should be supported with technical reasoning. This document is relatively simple and meant as a "quick overview" of -expecations for OSPRay. A more complete set of guidelines for all of C++ +expectations for OSPRay. A more complete set of guidelines for all of C++ can be found in the [ISO C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md). diff --git a/cmake/compiler/clang.cmake b/cmake/compiler/clang.cmake index 246f98610..89af95db0 100644 --- a/cmake/compiler/clang.cmake +++ b/cmake/compiler/clang.cmake @@ -15,7 +15,7 @@ if(OSPRAY_STRICT_BUILD) set(OSPRAY_CXX_FLAGS "-Wno-header-hygiene ${OSPRAY_CXX_FLAGS}") set(OSPRAY_CXX_FLAGS "-Wno-covered-switch-default ${OSPRAY_CXX_FLAGS}") set(OSPRAY_CXX_FLAGS "-Wno-date-time ${OSPRAY_CXX_FLAGS}") - set(OSPRAY_CXX_FLAGS "-Wno-unsafe-buffer-usage ${OSPRAY_CXX_FLAGS}") #we use pointer arithmetics on buffers + set(OSPRAY_CXX_FLAGS "-Wno-unsafe-buffer-usage ${OSPRAY_CXX_FLAGS}") #we use pointer arithmetic on buffers set(OSPRAY_CXX_FLAGS "-Wno-reserved-identifier ${OSPRAY_CXX_FLAGS}") #used in autogenerated ISPC headers # Should try to fix and remove... diff --git a/cmake/compiler/ispc.cmake b/cmake/compiler/ispc.cmake index 8ad845b10..daa1ab027 100644 --- a/cmake/compiler/ispc.cmake +++ b/cmake/compiler/ispc.cmake @@ -172,7 +172,7 @@ macro (ispc_compile) message(FATAL_ERROR "CMAKE_BUILD_TYPE (${CMAKE_BUILD_TYPE}) allows only the following values: Debug;Release;RelWithDebInfo") endif() - # turn space sparated list into ';' separated list + # turn space separated list into ';' separated list string(REPLACE " " ";" ISPC_OPT_FLAGS "${ISPC_OPT_FLAGS}") if (NOT WIN32) @@ -225,8 +225,8 @@ macro (ispc_compile) endforeach() endif() - # use relative path for genereated header file, because the path is - # included as commment and the header will be distributed + # use relative path for generated header file, because the path is + # included as comment and the header will be distributed set(headerfile "${outdir}/${fname}_ispc.h") file(RELATIVE_PATH headerfile ${CMAKE_CURRENT_BINARY_DIR} ${headerfile}) diff --git a/doc/api.md b/doc/api.md index 7f5be75b8..38ca74838 100644 --- a/doc/api.md +++ b/doc/api.md @@ -3368,8 +3368,8 @@ memory with OSPRay or to control which device should be used (e.g., in case multiple GPUs are present). If neither parameter is set, the `gpu` device will automatically create a context internally and select a GPU (that selection can be influenced via environment -variable `ONEAPI_DEVICE_SELECTOR`, see [Intel oneAPI DPC++ Compiler documentation] -(https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector)). +variable `ONEAPI_DEVICE_SELECTOR`, see [Intel oneAPI DPC++ Compiler +documentation](https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector)). Compile times for just in time compilation (JIT compilation) can be large. To resolve this issue we recommend enabling persistent JIT @@ -3382,8 +3382,8 @@ To reduce GPU memory allocation overhead when rendering scenes with many objects (geometries, instances, etc.), memory pooling should be enabled by setting the environment variable `SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR="1;0;shared:1M,0,2M"`. -See [Intel oneAPI DPC++ Compiler documentation] -(https://intel.github.io/llvm-docs/EnvironmentVariables.html#debugging-variables-for-level-zero-plugin) +See [Intel oneAPI DPC++ Compiler +documentation](https://intel.github.io/llvm-docs/EnvironmentVariables.html#debugging-variables-for-level-zero-plugin) for more details. ### Known Issues {-} diff --git a/modules/cpu/ISPCDevice.h b/modules/cpu/ISPCDevice.h index 68c1700ad..0f529b4aa 100644 --- a/modules/cpu/ISPCDevice.h +++ b/modules/cpu/ISPCDevice.h @@ -162,7 +162,7 @@ struct OSPRAY_SDK_INTERFACE ISPCDevice : public Device #ifdef OSPRAY_TARGET_SYCL /* Compute the rounded dispatch global size for the given work group size. - * SYCL requires that globalSize % workgroupSize == 0, ths function will + * SYCL requires that globalSize % workgroupSize == 0, this function will * round up globalSize and return nd_range(roundedSize, workgroupSize). * The kernel being launched must discard tasks that are out of bounds * bounds due to this rounding diff --git a/modules/cpu/common/World.ispc b/modules/cpu/common/World.ispc index 5daf26086..2447b83e3 100644 --- a/modules/cpu/common/World.ispc +++ b/modules/cpu/common/World.ispc @@ -50,7 +50,7 @@ unmasked void clippingIntersectionFilterV( instance, NULL, dg, *ray, DG_NG | DG_NS, true, *context->super.ffh); // Use geometry normal for clipping - // but use shading normal to check if invertion is needed + // but use shading normal to check if inversion is needed Nc = (dot(dg.Ns, dg.Ng) > 0.f) ? ray->Ng : neg(ray->Ng); } @@ -60,7 +60,7 @@ unmasked void clippingIntersectionFilterV( } // Based on clipping normal vector decide if the ray is - // entering clipping geometry (set positive hit value) or exitting clipping + // entering clipping geometry (set positive hit value) or exiting clipping // geometry (set negative hit value) const bool exitsClipping = (dot(ray->dir, Nc) > 0.f); ClippingHit cHit; diff --git a/modules/cpu/fb/FrameBuffer.h b/modules/cpu/fb/FrameBuffer.h index 3d76b9bbb..cacc63215 100644 --- a/modules/cpu/fb/FrameBuffer.h +++ b/modules/cpu/fb/FrameBuffer.h @@ -59,10 +59,8 @@ struct OSPRAY_SDK_INTERFACE FrameBuffer virtual utility::ArrayView getRenderTaskIDs( const float errorThreshold, const uint32_t spp) = 0; - // get number of pixels in x and y diretion vec2i getNumPixels() const; - // get the color format type for this Buffer ColorBufferFormat getColorBufferFormat() const; virtual float getVariance() const; @@ -139,7 +137,7 @@ struct OSPRAY_SDK_INTERFACE FrameBuffer bool accumulationFinished() const; private: - // for consistent reproducability of variance accumulation + // for consistent reproducibility of variance accumulation constexpr static uint32_t mtSeed = 43; std::mt19937 mtGen{mtSeed}; bool pickOdd{false}; diff --git a/modules/cpu/fb/LocalFB.cpp b/modules/cpu/fb/LocalFB.cpp index f8e9fd0f7..5d0836a2f 100644 --- a/modules/cpu/fb/LocalFB.cpp +++ b/modules/cpu/fb/LocalFB.cpp @@ -423,7 +423,7 @@ vec2i LocalFrameBuffer::getTaskStartPos(const uint32_t taskID) const devicert::AsyncEvent LocalFrameBuffer::postProcess() { // Calculate per-task variance if any samples accumulated into variance - // buffer, skip it if frameVariance overriden in writeTiles() + // buffer, skip it if frameVariance overridden in writeTiles() devicert::AsyncEvent event; const bool oddFrame = (getSh()->super.frameID & 1) == 1; if (varianceFrameOp && oddFrame && (frameVariance == float(inf))) diff --git a/modules/cpu/lights/SunSkyLight.h b/modules/cpu/lights/SunSkyLight.h index b3f41514d..a1595afd8 100644 --- a/modules/cpu/lights/SunSkyLight.h +++ b/modules/cpu/lights/SunSkyLight.h @@ -59,7 +59,7 @@ struct OSPRAY_SDK_INTERFACE SunSkyLight : public Light float intensityScale{0.025f}; }; -// Inlined defintions ///////////////////////////////////////////////////////// +// Inlined definitions ///////////////////////////////////////////////////////// inline uint32_t SunSkyLight::getShCount() const { diff --git a/modules/cpu/render/RendererRenderTaskFn.inl b/modules/cpu/render/RendererRenderTaskFn.inl index 9ae19390c..859097c35 100644 --- a/modules/cpu/render/RendererRenderTaskFn.inl +++ b/modules/cpu/render/RendererRenderTaskFn.inl @@ -90,7 +90,7 @@ static void Renderer_default_renderTask(const uniform vec3ui itemIndex, make_vec3f(Renderer_getBackground(self, screenSample.pos, ffh)); screenSample.normal = make_vec3f(0.f); - // The proper sample rendering function name is substitued here via macro + // The proper sample rendering function name is substituted here via macro renderSampleFn(self, fb, world, screenSample, ffh); col = col + screenSample.rgb; diff --git a/modules/cpu/render/pathtracer/NextEventEstimation.ispc b/modules/cpu/render/pathtracer/NextEventEstimation.ispc index 28072b095..31775b1b4 100644 --- a/modules/cpu/render/pathtracer/NextEventEstimation.ispc +++ b/modules/cpu/render/pathtracer/NextEventEstimation.ispc @@ -55,7 +55,8 @@ SYCL_EXTERNAL vec3f nextEventEstimation(const PathContext &pathContext, foreach_unique (l in light) ls = Light_dispatch_sample(l, pathVertex.dg, s, pathState.time, ffh); - // adjust the contibution with the probabiltiy of selecting the light source + // adjust the contribution with the probabiltiy of selecting the light + // source ls.weight = ls.weight / lightSelectionProb; ls.pdf *= lightSelectionProb; diff --git a/modules/cpu/render/pathtracer/TransparentShadow.ispc b/modules/cpu/render/pathtracer/TransparentShadow.ispc index fbf96bd5f..62d0b1331 100644 --- a/modules/cpu/render/pathtracer/TransparentShadow.ispc +++ b/modules/cpu/render/pathtracer/TransparentShadow.ispc @@ -26,7 +26,7 @@ SYCL_EXTERNAL __noinline vec3f transparentShadow( const uniform FeatureFlagsHandler &ffh) { const uniform FeatureFlags ff = getFeatureFlags(ffh); - // It's not possible to have transpareny shadows if we don't have any geometry + // It's not possible to have transparent shadows if we don't have any geometry if (!ff.geometry) { return lightContrib; } diff --git a/modules/mpi/ospray/fb/DistributedFrameBuffer.cpp b/modules/mpi/ospray/fb/DistributedFrameBuffer.cpp index b7fcbf7d3..6c6c94467 100644 --- a/modules/mpi/ospray/fb/DistributedFrameBuffer.cpp +++ b/modules/mpi/ospray/fb/DistributedFrameBuffer.cpp @@ -439,7 +439,7 @@ void DistributedFrameBuffer::processMessage(MasterTileMessage_FB *msg) } // All IDs are sent if any were requested, however we need to write only the // ones that actually exist in the local FB since it doesn't allocate - // buffers for the non-existant channels + // buffers for the non-existent channels if (hasPrimitiveIDBuffer) { pidBuf = reinterpret_cast(data); } diff --git a/ospray/common/DeviceRT.h b/ospray/common/DeviceRT.h index 094286c16..7ca4a96f2 100644 --- a/ospray/common/DeviceRT.h +++ b/ospray/common/DeviceRT.h @@ -273,7 +273,7 @@ inline Device &DeviceAllocator::getDevice() const // Use it for data that needs the highest read/write performance on the device. // The buffer supports initialization from system (non-USM) memory. Preferably // should be used for all scene data that does not need to be updated from or -// transfered back to the host. +// transferred back to the host. template struct BufferDevice { @@ -319,7 +319,7 @@ BufferDevice::BufferDevice(Device &device, const std::vector &v) ptr(static_cast(device.deviceMalloc(v.size() * sizeof(T)))) { // Schedule buffer copying and wait till completed so the input resource can - // be released immediatelly + // be released immediately AsyncEvent event = device.memcpy(ptr, v.data(), v.size() * sizeof(T)); event.wait(); } @@ -331,7 +331,7 @@ BufferDevice::BufferDevice(Device &device, T *data, std::size_t count) ptr(static_cast(device.deviceMalloc(count * sizeof(T)))) { // Schedule buffer copying and wait till completed so the input resource can - // be released immediatelly + // be released immediately AsyncEvent event = device.memcpy(ptr, data, count * sizeof(T)); event.wait(); } @@ -378,7 +378,7 @@ inline std::unique_ptr> make_buffer_device_unique( // Buffer in the device memory with host memory shadow // For usages that need the highest read/write efficiency on the device, similar -// to `BufferDevice`, but additionally the data has to be transfered from/to +// to `BufferDevice`, but additionally the data has to be transferred from/to // host periodically, e.g. framebuffers. After construction and initialization // of the host/shadow buffer, an explicit call to copyToDevice() is required so // the data will be visible for the device. Beware, it may use pinned (not diff --git a/ospray/include/ospray/ospray_util.h b/ospray/include/ospray/ospray_util.h index 1f9a7d36f..cdcabaa7a 100644 --- a/ospray/include/ospray/ospray_util.h +++ b/ospray/include/ospray/ospray_util.h @@ -86,7 +86,7 @@ OSPRAY_INTERFACE void ospSetObjectAsData(OSPObject target, // Rendering helpers ////////////////////////////////////////////////////////// -// Start a frame task and immediately wait on it, return frame buffer varaince +// Start a frame task and immediately wait on it, return frame buffer variance OSPRAY_INTERFACE float ospRenderFrameBlocking( OSPFrameBuffer, OSPRenderer, OSPCamera, OSPWorld); diff --git a/scripts/files-to-md5.sh b/scripts/files-to-md5.sh index a279713f0..5b77fbf35 100755 --- a/scripts/files-to-md5.sh +++ b/scripts/files-to-md5.sh @@ -46,7 +46,7 @@ set -e for FILE in $BASELINE_INPUT_IMAGES_DIR/*; do # Copy file to local tmp directory with new name (based on md5 from this img) cp $FILE $LOCAL_TMP_DIR/`md5 $FILE` - # Create/Filll metadata file in ospray repo + # Create/Fill metadata file in ospray repo # so we can link img in remote repo by this md5 string md5 $FILE > $BASELINE_MD5_OUTPUT_DIR/`basename $FILE`.md5 done diff --git a/scripts/superbuild/README.md b/scripts/superbuild/README.md index 187241e19..72dd97085 100644 --- a/scripts/superbuild/README.md +++ b/scripts/superbuild/README.md @@ -14,7 +14,7 @@ cmake [/scripts/superbuild] cmake --build . ``` -On Windows make sure to select a 64bit generator, e.g. +On Windows make sure to select a 64\ bit generator, e.g. ```sh cmake -G "Visual Studio 17 2022" [/scripts/superbuild]