Embree v2.16.1

• Workaround for compile issues with Visual Studio 2017
• Fixed bug in subdiv code for static scenes when using tessellation levels larger than 50.
• Fixed low performance when adding many geometries to a scene.
• Fixed high memory consumption issue when using instances in dynamic scene (by disabling two level builder for user geometries and instances).

Embree v2.16.0

• Improved multi-segment motion blur support for scenes with different number of time steps per mesh.
• New top level BVH builder that improves build times and BVH quality of two-level BVHs.
• Added support to enable only a single ISA. Previously code was always compiled for SSE2.
• Improved single ray tracing performance for incoherent rays on AVX512 architectures by 5-10%.
• Improved packet/hybrid ray tracing performance for incoherent rays on AVX512 architectures by 10-30%.
• Improved stream ray tracing performance for coherent rays in structure-of-pointers layout by 40-70%.
• BVH builder for compact scenes of triangles and quads needs essentially no temporary memory anymore. This doubles the maximal scene size that can be rendered in compact mode.
• Triangles no longer store the geometry normal in fast/default mode which reduces memory consumption by up to 20%.
• Compact mode uses BVH4 now consistently which reduces memory consumption by up to 10%.
• Reduced memory consumption for small scenes (of 10k-100k primitives) and dynamic scenes.
• Improved performance of user geometries and instances through BVH8 support.
• The API supports now specifying the geometry ID of a geometry at construction time. This way matching the geometry ID used by Embree and the application is simplified.
• Fixed a bug that would have caused a failure of the BVH builder for dynamic scenes when run on a machine with more then 1000 threads.
• Fixed a bug that could have been triggered when reaching the maximal number of mappings under Linux (vm.max_map_count). This could have happened when creating a large number of small static scenes.
• Added huge page support for Windows and MacOSX (experimental).
• Added support for Visual Studio 2017.
• Removed support for Visual Studio 2012.
• Precompiled binaries now require a CPU supporting at least the SSE4.2 ISA.
• We no longer provide precompiled binaries for 32 bit on Windows.
• Under Windows one now has to use the platform toolset option in CMake to switch to Clang or the Intel® Compiler.
• Fixed a bug for subdivision meshes when using the incoherent scene flag.
• Fixed a bug in the line geometry intersection, that caused reporting an invalid line segment intersection with primID -1.
• Buffer stride for vertex buffers of different time steps of triangle and quad meshes have to be identical now.
• Fixed a bug in the curve geometry intersection code when passed a perfect cylinder.

Embree v2.15.0

• Added rtcCommitJoin mode that allows thread to join a build operation. When using the internal tasking system this allows Embree to solely use the threads that called rtcCommitJoin to build the scene, while previously also normal worker threads participated in the build. You should no longer use rtcCommit to join a build.
• Added rtcDeviceSetErrorFunction2 API call, which sets an error callback function which additionally gets passed a user provided pointer (rtcDeviceSetErrorFunction is now deprecated).
• Added rtcDeviceSetMemoryMonitorFunction2 API call, which sets a memory monitor callback function which additionally get passed a user provided pointer. (rtcDeviceSetMemoryMonitorFunction is now deprecated).
• Build performance for hair geometry improved by up to 2x.
• Standard BVH build performance increased by 5%.
• Added API extension to use internal Morton-code based builder, the standard binned-SAH builder, and the spatial split-based SAH builder.
• Added support for BSpline hair and curves. Embree uses either the Bezier or BSpline basis internally, and converts other curves, which requiring more memory during rendering. For reduced memory consumption set the EMBREE_NATIVE_SPLINE_BASIS to the basis your application uses (which is set to BEZIER by default).
• Setting the number of threads through tbb::taskscheduler_init object on the application side is now working properly.
• Windows and Linux releases are build using AVX512 support.
• Implemented hybrid traversal for hair and line segments for improved ray packet performance.
• AVX512 code compiles with Clang 4.0.0
• Fixed crash when ray packets were disabled in CMake.

Embree v2.14.0

• Added ignore_config_files option to init flags that allows the
  application to ignore Embree configuration files.
• Face-varying interpolation is now supported for subdivision surfaces.
• Up to 16 user vertex buffers are supported for vertex
  attribute interpolation.
• Deprecated rtcSetBoundaryMode function, please use the new
  rtcSetSubdivisionMode function.
• Added RTC_SUBDIV_PIN_BOUNDARY mode for handling boundaries of
  subdivision meshes.
• Added RTC_SUBDIV_PIN_ALL mode to enforce linear interpolation
  for subdivision meshes.
• Optimized object generation performance for dynamic scenes.
• Reduced memory consumption when using lots of small dynamic objects.
• Fixed bug for subdivision surfaces using low tessellation rates.
• Hair geometry now uses a new ribbon intersector that intersects with
  ray-facing quads. The new intersector also returns the
  v-coordinate of the hair intersection, and fixes artefacts at junction
  points between segments, at the cost of a small performance hit.
• Added rtcSetBuffer2 function, that additionally gets the number of
  elements of a buffer. In dynamic scenes, this function allows to
  quickly change buffer sizes, making it possible to change the number of
  primitives of a mesh or the number of crease features for subdivision
  surfaces.
• Added simple 'viewer_anim' tutorial for rendering key
  frame animations and 'buildbench' for measuring BVH (re-)build
  performance for static and dynamic scenes.
• Added more AVX512 optimizations for future architectures.

Embree v2.13.0

• Improved performance for compact (but not robust) scenes.
• Added robust mode for motion blurred triangles and quads.
• Added fast dynamic mode for user geometries.
• Up to 20% faster BVH build performance on the second generation
  Intel® Xeon Phi™ processor codenamed Knights Landing.
• Improved quality of the spatial split builder.
• Improved performance for coherent streams of ray packets (SOA layout),
  e.g. for fast primary visibility.
• Various bug fixes in tessellation cache, quad-based spatial
  split builder, etc.

Embree v2.12.0

• Added support for multi-segment motion blur for all primitive
  types.
• API support for stream of pointers to single rays (rtcIntersect1Mp and
  rtcOccluded1Mp)
• Improved BVH refitting performance for dynamic scenes.
• Improved high-quality mode for quads (added spatial split builder
  for quads)
• Faster dynamic scenes for triangle and quad-based meshes on AVX2
  enabled machines.
• Performance and correctness bugfix in optimization for streams of
  coherent (single) rays.
• Fixed large memory consumption (issue introduced in Embree
  v2.11.0). If you use Embree v2.11.0 please upgrade to Embree
  v2.12.0.
• Reduced memory consumption for dynamic scenes containing small meshes.
• Added support to start and affinitize TBB worker threads by passing
  "start_threads=1,set_affinity=1" to rtcNewDevice. These settings
  are recommended on systems with a high thread count.
• rtcInterpolate2 can now be called within a displacement shader.
• Added initial support for Microsoft's Parallel Pattern Library (PPL) as
  tasking system alternative (for optimial performance TBB is highly recommended).
• Updated to TBB 2017 which is released under the Apache v2.0
  license.
• Dropped support for Visual Studio 2012 Win32 compiler. Visual
  Studio 2012 x64 is still supported.

Embree v2.11.0

• Improved performance for streams of coherent (single) rays flagged
  with RTC_INTERSECT_COHERENT. For such coherent ray streams, e.g.
  primary rays, the performance typically improves by 1.3–2×.
• New spatial split BVH builder for triangles, which is 2–6× faster
  than the previous version and more memory conservative.
• Improved performance and scalability of all standard BVH builders on
  systems with large core counts.
• Fixed rtcGetBounds for motion blur scenes.
• Thread affinity is now on by default when running on the latest
  Intel® Xeon Phi™ processor.
• Added initial AVX512 support for future Intel® Xeon processors.

Embree v2.10.0

• Added a new curve geometry which renders the sweep surface of a
  circle along a Bézier curve.
• Intersection filters can update the 'tfar' ray distance.
• Geometry types can get disabled at compile time.
• Modified and extended the ray stream API.
• Added new callback mechanism for the ray stream API.
• Improved ray stream performance (up to 5-10%).
• Up to 20% faster morton builder on machines with large core counts.
• Lots of optimizations for the second generation Intel® Xeon Phi™ coprocessor codenamed Knights Landing.
• Added experimental support for compressed BVH nodes (reduces node
  size to 56--62% of uncompressed size). Compression introduces a
  typical performance overhead of ~10%.
• Bugfix in backface culling mode. We do now properly cull the
  backfaces and not the frontfaces.
• Feature freeze for the first generation Intel® Xeon Phi™ coprocessor
  codenamed Knights Corner. We will still maintain and add bug fixes
  to Embree v2.9.0, but Embree 2.10 and future versions will no longer support it.

Embree v2.9.0

• Improved shadow ray performance (10% to 100% depending on the scene).
• Added initial support for ray streams (10% to 30% higher performance depending on ray coherence in the stream).
• Added support to calculate second order derivatives using the rtcInterpolate2 function.
• Changed the parametrization for triangular subdivision faces to the same scheme used for pentagons.
• Added support to query the Embree configuration using the rtcDeviceGetParameter function.

Embree v2.8.0

• Added support for line segment geometry.
• Added support for quad geometry (replaces triangle-pairs feature).
• Added support for linear motion blur of user geometries.
• Improved performance through AVX512 optimizations.
• Improved performance of lazy scene build (when using TBB 4.4 update 2).
• Improved performance through huge page support under Linux.