{"id":13574616,"url":"https://github.com/RenderKit/openpgl","last_synced_at":"2025-04-04T15:31:37.523Z","repository":{"id":37775323,"uuid":"473512033","full_name":"RenderKit/openpgl","owner":"RenderKit","description":"Intel(R) Open Path Guiding Library","archived":false,"fork":false,"pushed_at":"2024-10-03T10:34:26.000Z","size":13932,"stargazers_count":280,"open_issues_count":6,"forks_count":25,"subscribers_count":16,"default_branch":"main","last_synced_at":"2024-10-14T22:01:57.336Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/RenderKit.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-03-24T08:10:12.000Z","updated_at":"2024-10-12T23:28:34.000Z","dependencies_parsed_at":"2024-08-16T10:49:46.723Z","dependency_job_id":"216f060d-9e0b-4397-a208-d60c6f9dab0f","html_url":"https://github.com/RenderKit/openpgl","commit_stats":null,"previous_names":["renderkit/openpgl","openpathguidinglibrary/openpgl"],"tags_count":7,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RenderKit%2Fopenpgl","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RenderKit%2Fopenpgl/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RenderKit%2Fopenpgl/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RenderKit%2Fopenpgl/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/RenderKit","download_url":"https://codeload.github.com/RenderKit/openpgl/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247202837,"owners_count":20900847,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-01T15:00:53.055Z","updated_at":"2025-04-04T15:31:32.515Z","avatar_url":"https://github.com/RenderKit.png","language":"C++","funding_links":[],"categories":["Table of Contents"],"sub_categories":["Data Visualization and Rendering"],"readme":"# Intel® Open Path Guiding Library\n\nThis is release v0.6.0 of Intel® Open PGL. For changes and new features,\nsee the [changelog](CHANGELOG.md). Visit http://www.openpgl.org for more\ninformation.\n\n# Overview\n\nThe Intel® Open Path Guiding Library (Intel® Open PGL) implements a set\nof representations and training algorithms needed to integrate path\nguiding into a renderer. Open PGL offers implementations of current\nstate-of-the-art path guiding methods, which increase the sampling\nquality and, therefore, the efficiency of a renderer. The goal of Open\nPGL is to provide implementations that are well tested and robust enough\nto be used in a production environment.\n\nThe representation of the guiding field is learned during rendering and\nupdated on a per-frame basis using radiance/importance samples generated\nduring rendering. At each vertex of a random path/walk, the guiding\nfield is queried for a local distribution (e.g., incident radiance),\nguiding local sampling decisions (e.g., directions).\n\nCurrently supported path guiding methods include: guiding directional\nsampling decisions on surfaces and inside volumes based on a learned\nincident radiance distribution or its product with BSDF components\n(i.e., cosine lobe) or phase functions (i.e., single lobe HG).\n\nOpen PGL offers a C API and a C++ wrapper API for higher-level\nabstraction. The current implementation is optimized for the latest\nIntel® processors with support for SSE, AVX, AVX2, and AVX-512\ninstructions.\n\u003c!--, and for ARM processors with support for NEON instructions.--\u003e\n\nOpen PGL is part of the [Intel® oneAPI Rendering\nToolkit](https://software.intel.com/en-us/rendering-framework) and has\nbeen released under the permissive [Apache 2.0\nlicense](http://www.apache.org/licenses/LICENSE-2.0).\n\n|                                                                ![Example rendering without and with Open PGL](/doc/images/example.png)                                                                 |\n|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|\n| Path traced image of a variation of the Nishita Sky Demo scene from Blender Studio (CC0) without and with using Open PGL to guide directional samples (i.e., on surfaces and inside the water volume). |\n\n# Disclaimer\n\nThe current version of Open PGL is still in a pre v1.0 stage and should\nbe used with caution in any production related environment. The API\nspecification is still in flux and might change with upcoming releases.\n\n# Version History\n\n## Open PGL 0.6.0\n\n-   Api changes:\n    -   `Device` added `numThread` parameter (default = 0) to the\n        constructor to set the number of threads used by `Open PGL`\n        during training. The default value of `0` uses all threads\n        provided by `TBB`. If the renderer uses `TBB` as well and\n        regulates the thread count this count is also used by\n        `Open PGL`.\n    -   `SurfaceSamplingDistribution` and `VolumeSamplingDistribution`:\n        -   Added `GetId` function to return the unique id of the\n            spatial structure used to query the sampling distriubtion.\n    -   `Field` and `SampleStorage`, added `Compare` function to check\n        if the data stored in different instances (e.g., generated by\n        two separate runs) are similar (i.e., same spatial subdivisions\n        and directional distributions).\n    -   `Field`:\n        -   The constructor of the `Field` class now takes a\n            `FieldConfig` instead of a `PGLFieldArguments` object.\n            **(BREAKING API CHANGE)**\n        -   `GetSurfaceStatistics` and `GetVolumeStatistics` functions\n            are added to query statistics about the surface and volume\n            guiding field. The functions return a `FieldStatistics`\n            object. Note, querying the statistics of a `Field`\n            introduces a small overhead.\n    -   `FieldStatistics`:\n        -   This class store different statistics about a `Field`, such\n            as, number and size of spatial nodes, statistics about the\n            directional distributions, and the times spend for full and\n            separate steps of the last `Update` step. The statistics can\n            be queried as a full string (useful for logging) or as CSV\n            strings (useful for analysis and plotting).\n        -   `ToString`: Returns a string printing all statistics.\n        -   `HeaderCSVString`: Returns the CSV header sting with the\n            names of each statistic.\n        -   `ToCSVString`: Returns the CSV value sting of each\n            statistic.\n    -   `FieldConfig`:\n        -   This class is added to replace the `PGLFieldArguments`\n            struct when using the C++ API. -`Init`: the function\n            initializes the parameters of the `FieldConfig` (i.e.,\n            similar to `pglFieldArgumentsSetDefaults`). Additional\n            parameters (`deterministic` and `maxSamplesPerLeaf`) are\n            introduced to enable deterministic behavior and to control\n            the spatial subdivision granularity.\n            -`SetSpatialStructureArgMaxDepth`: this function can be\n            called after `Init` to the the maximum tree depth of the\n            spatial structure.\n    -   `pglFieldArgumentsSetDefaults`: Adding two additional parameters\n        `deterministic` and `maxSamplesPerLeaf`. **(BREAKING API\n        CHANGE)**\n-   Tools:\n    -   Added a set of command line tools which are build when enabling\n        the `OPENPGL_BUILD_TOOLS` Cmake flag.\n        -   `openpgl_bench`: Tool to time different components of\n            `Open PGL` such as the full training of a `Field` or the\n            querying (initialization) of `SamplingDistributions`.\n        -   `openpgl_debug`: Tool to `validate` and `compare` stored\n            `SampleStorage` and `Field` objects or retrain a `Field`\n            from scratch using multiple stored sets (iterations) of\n            stored samples.\n-   Optimizations:\n    -   Spatial structure (Kd-tree) build is now fully multithreaded.\n        This improves training performance on machines with higher core\n        counts, especially when using `deterministic` training.\n    -   Kd-tree switched to use cache-friendlier `TreeLets` instead of\n        single `TreeNode` structures.\n-   Bugfixes:\n    -   `Field` fixed some non-deterministic behavior when spatial cache\n        does not receive any training data during a training iteration\n        due to a large number of training iterations.\n    -   Removed legacy/broken support for `OpenMP` threading since there\n        is a dependency to `TBB` anyway.\n    -   Fixed build problems on (non-Mac) `ARM` systems.\n\n## Open PGL 0.5.0\n\n-   Api changes:\n\n    -   `PathSegmentStorage`:\n        -   Removed support for splatting training samples due to the\n            fact that knn-lookups have proven to be better. Therefore,\n            the function attributes `splatSamples` and `sampler` have\n            been removed from the `PrepareSamples` function.\n\n        -   Added `PropagateSamples` method prepare and push samples to\n            the `SampleStorage` The goal is to replace `PrepareSamples`,\n            `GetSamples` and `AddSamples`.\n    -   `Sampler`:\n        -   Removed since it is not used/needed anymore.\n    -   `SurfaceSamplingDistribution` and `VolumeSamplingDistribution`:\n        -   The usage of parallax-compensation is now connected to the\n            guiding distribution type. Therefore the explicit\n            `useParallaxCompensation` parameter is removed from the\n            `Init` functions of the `SamplingDistributions`.  \n        -   Added `IncomingRadiancePDF` function that returns an\n            approximation of the incoming radiance distribution. This\n            PDF does not need to be related to the actual sampling PDF\n            but can be used for Resampled Importance Sampling (RIS).\n    -   `Field`:\n        -   Adding `UpdateSurface` and `UpdateVolume` function to\n            update/train the surface and volume field separately.\n    -   `SampleStorage`:\n        -   Adding `ClearSurface` and `ClearVolume` function to clear\n            the surface and volume samples separately. This allows to\n            wait until a specific number of samples is collected for the\n            surface or volume cache before updating/fitting the `Field`.\n\n-   Deactivating/removing `OMP` threading support since it would still\n    have a dependency on `TBB`\n\n-   Bugfixes:\n\n    -   Fixing bug causing crash during `Field::Update` when in previous\n        iterations no volume or surface samples were present.\n\n## Open PGL 0.4.1\n\n-   Bugfixes:\n    -   Fixing bug introduced in `0.4.0` when using\n        `ApplySingleLobeHenyeyGreensteinProduct()` for VMM-based\n        representations\n\n## Open PGL 0.4.0\n\n-   Performance:\n\n    -   Optimized KNN lookup of guiding caches (x3 speed-up).\n    -   Optimized Cosine product for VMM based representations.\n\n-   Dependencies:\n\n    -   Removed the Embree library dependency for KNN lookups in favour\n        of the header-only library nanoflann.\n\n-   Adding ARM Neon support (e.g., Apple M1).\n\n-   Fixing memory alignment bug for higher SIMD widths.\n\n-   `PathSegmentStorage`:\n\n    -   Fixing bug when multiple refracted/reflected events hit a\n        distant source (i.e., environment map) by clamping to a max\n        distance.\n    -   Adding `GetMaxDistance` and `SetMaxDistance` methods.\n    -   Adding `GetNumSegments` and `GetNumSamples` methods.\n\n-   `Field`:\n\n    -   Stopped tracing a total number of spp statistic since it is not\n        really useful.\n        -   Removed the `GetTotalSPP` function.\n        -   Removed the `numPerPixelSamples` parameter from the `Update`\n            function.\n\n## Open PGL 0.3.1\n\n-   `Field`:\n    -   Added `Reset()` function to reset a guiding field (e.g., when\n        the lighting or the scene geometry changed)\n-   `PathSegmentStorage`:\n    -   Fixed bug when using `AddSample()`\n\n## Open PGL 0.3.0\n\n-   Added CMake Superbuild script to build Open PGL, including all its\n    dependencies.  \n    The dependencies (e.g., TBB and Embree) are downloaded, built, and\n    installed automatically.\n\n-   Added support for different SIMD optimizations (SSE, AVX2, AVX-512).\n    The optimization type can be chosen when initializing the `Device`.\n\n-   Added support for directional quadtrees for the directional\n    representation.\n\n-   `PathSegmentStorage`:\n\n    -   Added debug function `CalculatePixelEstimate` to validate if the\n        stored path segment information represents the sampling behavior\n        of the render (i.e., the resulting RGB value should match the\n        pixel value the renderer adds to the framebuffer)\n\n-   `SurfaceSamplingDistribution`:\n\n    -   Added support for guiding based on the product of a\n        normal-oriented cosine lobe and the incident radiance\n        distribution: `(ApplyCosineProduct)` This feature is only\n        supported for VMM-based directional distributions. Support can\n        be checked with `SupportsApplyCosineProduct()`.\n\n-   `VolumeSamplingDistribution`:\n\n    -   Added support for guiding based on the product of a single lobe\n        HG phase function and the incident radiance distribution:\n        `ApplySingleLobeHenyeyGreensteinProduct()` This feature is only\n        supported for VMM-based directional distributions. Support can\n        be checked with\n        `SupportsApplySingleLobeHenyeyGreensteinProduct()`.\n\n## Open PGL 0.1.0\n\n-   Initial release of Open PGL Features:\n    -   Incremental learning/updating of a 5D spatio-directional\n        radiance field from radiance samples (see `Field`).\n    -   Directional representation based on (parallax-aware) von\n        Mises-Fisher mixtures.\n    -   `PathSegmentStorage` is a utility class to help keep track of\n        all path segment information and generate radiance samples when\n        a path/random walk is finished/terminated.\n    -   Support for guided importance sampling of directions on surfaces\n        (see `SurfaceSamplingDistribution`) and inside volumes (see\n        `VolumeSamplingDistribution`)\n-   Added C-API and C++-API headers\n    -   C-API: `#include \u003copenpgl/openpgl.h\u003e`\n    -   C++-API: `#include \u003copenpgl/cpp/OpenPGL.h\u003e` and the namespace\n        `openpgl::cpp::`\n\n# Support and Contact\n\nOpen PGL is under active development. Though we do our best to guarantee\nstable release versions, a certain number of bugs, as-yet-missing\nfeatures, inconsistencies, or any other issues are still possible.\nShould you find any such issues, please report them immediately via\n[Open PGL’s GitHub Issue\nTracker](https://github.com/OpenPathGuidingLibrary/openpgl/issues) (or,\nif you should happen to have a fix for it, you can also send us a pull\nrequest).\n\n# Reference\n\n``` code\n@misc{openpgl,\n   Author = {Herholz, Sebastian and Dittebrandt, Addis},\n   Year = {2022},\n   Note = {http://www.openpgl.org},\n   Title = {Intel{\\textsuperscript{\\tiny\\textregistered}}\n Open Path Guiding Library}\n}\n```\n\n# Building Open PGL from source\n\nThe latest Open PGL sources are always available at the [Open PGL GitHub\nrepository](http://github.com/openpathguidinglibrary/openpgl). The\ndefault `main` branch should always point to the latest tested bugfix\nrelease.\n\n## Prerequisites\n\nOpen PGL currently supports Linux and Windows. In addition, before\nbuilding Open PGL you need the following prerequisites:\n\n-   You can clone the latest Open PGL sources via:\n\n        git clone https://github.com/openpathguidinglibrary/openpgl.git\n\n-   To build Open PGL you need [CMake](http://www.cmake.org), any form\n    of C++11 compiler (we recommend using GCC, but also support Clang\n    and MSVC), and standard Linux development tools.\n\n-   Open PGL depends on Embree, which is available at the [Embree GitHub\n    repository](https://github.com/embree/embree).\n\n-   Open PGL depends on TBB, which is available at the [TBB GitHub\n    repository](https://github.com/oneapi-src/oneTBB).\n\nDepending on your Linux distribution, you can install these dependencies\nusing `yum` or `apt-get`. Some of these packages might already be\ninstalled or might have slightly different names.\n\n## CMake Superbuild\n\nFor convenience, Open PGL provides a CMake Superbuild script which will\npull down Open PGL’s dependencies and build Open PGL itself. The result\nis an install directory including all dependencies.\n\nRun with:\n\n``` bash\nmkdir build\ncd build\ncmake ../superbuild\ncmake  --build .\n```\n\nThe resulting `install` directory (or the one set with\n`CMAKE_INSTALL_PREFIX`) will have everything in it, with one\nsubdirectory per dependency.\n\nCMake options to note (all have sensible defaults):\n\n-   `CMAKE_INSTALL_PREFIX` will be the root directory where everything\n    gets installed.\n-   `BUILD_JOBS` sets the number given to `make -j` for parallel builds.\n-   `INSTALL_IN_SEPARATE_DIRECTORIES` toggles installation of all\n    libraries in separate or the same directory.\n-   `BUILD_TBB_FROM_SOURCE` specifies whether TBB should be built from\n    source or the releases on GitHub should be used. This must be ON\n    when compiling for ARM.\n\nFor the full set of options, run `ccmake [\u003cPGL_ROOT\u003e/superbuild]`.\n\n## Standard CMake build\n\nAssuming the above prerequisites are all fulfilled, building Open PGL\nthrough CMake is easy:\n\nCreate a build directory, and go into it:\n\n``` bash\n        mkdir build\n        cd build\n```\n\nConfigure the Open PGL build using:\n\n``` bash\n        cmake -DCMAKE_INSTALL_PREFIX=[openpgl_install] ..\n```\n\n-   CMake options to note (all have sensible defaults):\n\n    -   `CMAKE_INSTALL_PREFIX` will be the root directory where\n        everything gets installed.\n\n    -   `OPENPGL_BUILD_STATIC` if Open PGL should be built as a static\n        or shared library (default `OFF`).\n\n    -   `OPENPGL_ISA_AVX512` if Open PGL is compiled with AVX-512\n        support (default `OFF`).\n\n    -   `OPENPGL_ISA_NEON` and `OPENPGL_ISA_NEON2X` if Open PGL is\n        compiled with NEON or double pumped NEON support (default\n        `OFF`).\n\n    -   `OPENPGL_LIBRARY_NAME`: Specifies the name of the Open PGL\n        library file created. By default the name `openpgl` is used.\n\n    -   `OPENPGL_TBB_ROOT` location of the TBB installation.\n\n    -   `OPENPGL_TBB_COMPONENT` the name of the TBB component/library\n        (default `tbb`).\n\nBuild and install Open PGL using:\n\n``` bash\n        cmake build\n        cmake install\n```\n\n# Including Open PGL into a project\n\n## Including into CMake build scripts.\n\nTo include Open PGL into a project which is using CMake as a build\nsystem, one can simply use the CMake configuration files provided by\nOpen PGL.\n\nTo make CMake aware of Open PGL’s CMake configuration scripts the\n`openpgl_DIR` has to be set to their location during configuration:\n\n``` bash\ncmake -Dopenpgl_DIR=[openpgl_install]/lib/cmake/openpgl-0.6.0 ..\n```\n\nAfter that, adding OpenPGL to a CMake project/target is done by first\nfinding Open PGL using `find_package()` and then adding the\n`openpgl:openpgl` targets to the project/target:\n\n``` cmake\n# locating Open PGL library and headers \nfind_package(openpgl REQUIRED)\n\n# setting up project/target\n...\nadd_executable(myProject ...)\n...\n\n# adding Open PGL to the project/target\ntarget_include_directories(myProject openpgl::openpgl)\n\ntarget_link_libraries(myProject openpgl::openpgl)\n```\n\n## Including Open PGL API headers\n\nOpen PGL offers two types of APIs.\n\nThe C API is C99 conform and is the basis for interacting with Open PGL.\nTo use the C API of Open PGL, one only needs to include the following\nheader:\n\n``` c\n#include \u003copenpgl/openpgl.h\u003e\n```\n\nThe C++ API is a header-based wrapper of the C API, which offers a more\ncomfortable, object-oriented way of using Open PGL. To use the C++ API\nof Open PGL, one only needs to include the following header:\n\n``` c++\n#include \u003copenpgl/cpp/OpenPGL.h\u003e\n```\n\n# Open PGL API\n\nThe API specification of Open PGL is currently still in a “work in\nprogress” stage and might change with the next releases - depending on\nthe community feedback and library evolution.\n\nWe, therefore, only give here a small overview of the C++ class\nstructures and refer to the individual class header files for detailed\ninformation.\n\n## Device\n\n``` c++\n#include \u003copenpgl/cpp/Device.h\u003e\n```\n\nThe `Device` class is a key component of OpenPGL. It defines the backend\nused by Open PGL. OpenPGL supports different CPU backends using SSE,\nAVX, or AVX-512 optimizations.\n\nNote: support for different GPU backends is planned in future releases.\n\n## Field\n\n``` c++\n#include \u003copenpgl/cpp/Field.h\u003e\n```\n\nThe `Field` class is a key component of Open PGL. An instance of this\nclass holds the spatio-directional guiding information (e.g.,\napproximation of the incoming radiance field) for a scene. The `Field`\nis responsible for storing, learning, and accessing the guiding\ninformation. This information can be the incidence radiance field\nlearned from several training iterations across the whole scene. The\n`Field` holds separate approximations for surface and volumetric\nradiance distributions, which can be accessed separately. The\nrepresentation of a scene’s radiance distribution is usually separated\ninto a positional and directional representation using a spatial\nsubdivision structure. Each spatial leaf node (a.k.a. Region) contains a\ndirectional representation for the local incident radiance distribution.\n\n## SurfaceSamplingDistribution\n\n``` c++\n#include \u003copenpgl/cpp/SurfaceSamplingDistribution.h\u003e\n```\n\nThe `SurfaceSamplingDistribution` class represents the guiding\ndistribution used for sampling directions on surfaces. The sampling\ndistribution is often proportional to the incoming radiance distribution\nor its product with components of a BSDF model (e.g., cosine term). The\nclass supports functions for sampling and PDF evaluations.\n\n## VolumeSamplingDistribution\n\n``` c++\n#include \u003copenpgl/cpp/VolumeSamplingDistribution.h\u003e\n```\n\nThe `VolumeSamplingDistribution` class represents the guiding\ndistribution used for sampling directions inside volumes. The sampling\ndistribution is often proportional to the incoming radiance distribution\nor its product with the phase function (e.g., single lobe HG). The class\nsupports functions for sampling and PDF evaluations.\n\n## SampleData\n\n``` c++\n#include \u003copenpgl/cpp/SampleData.h\u003e\n```\n\nThe `SampleData` struct represents a radiance sample (e.g., position,\ndirection, value). Radiance samples are generated during rendering and\nare used to train/update the guiding field (e.g., after each rendering\nprogression). A `SampleData` object is created at each vertex of a\nrandom walk/path. To collect the data at a specific vertex, the whole\npath (from its endpoint to the current vertex) must be considered, and\ninformation (e.g., radiance) must be backpropagated.\n\n## SampleStorage\n\n``` c++\n#include \u003copenpgl/cpp/SampleStorage.h\u003e\n```\n\nThe `SampleStorage` class is a storage container collecting all\nSampleData generated during rendering. It stores the (radiance/photon)\nsamples generated during rendering. The implementation is thread save\nand supports concurrent adding of samples from multiple threads. As a\nresult, only one instance of this container is needed per rendering\nprocess. The stored samples are later used by the Field class to\ntrain/learn the guiding field (i.e., radiance field) for a scene.\n\n## PathSegmentStorage\n\n``` c++\n#include \u003copenpgl/cpp/PathSegmentStorage.h\u003e\n```\n\nThe `PathSegmentStorage` is a utility class to help generate multiple\n`SampleData` objects during the path/random walk generation process. For\nthe construction of a path/walk, each new `PathSegment` is stored in the\n`PathSegmentStorage`. When the walk is finished or terminated, the\n-radiance- SampleData is generated using a backpropagation process. The\nresulting samples are then be passed to the global `SampleDataStorage`.\n\nNote: The `PathSegmentStorage` is just a utility class meaning its usage\nis not required. It is possible to for the users to use their own method\nfor generating `SampleData` objects during rendering.\n\n## PathSegment\n\n``` c++\n#include \u003copenpgl/cpp/PathSegment.h\u003e\n```\n\nThe `PathSegment` struct stores all required information for a path\nsegment (e.g., position, direction, PDF, BSDF evaluation). A list of\nsucceeding segments (stored in a `PathSegmentStorage`) is used to\ngenerate `SampleData` for training the guiding field.\n\n# Projects that make use of Open PGL\n\nTBA\n\n# Projects that are closely related to Open PGL\n\n-   The [Intel® oneAPI Rendering\n    Toolkit](https://software.intel.com/en-us/rendering-framework)\n\n-   The [Intel® Embree](http://embree.github.io) Ray Tracing Kernel\n    Framework\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FRenderKit%2Fopenpgl","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FRenderKit%2Fopenpgl","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FRenderKit%2Fopenpgl/lists"}