Draft Material in core

doc/developer.md

@@ -28,6 +28,8 @@ Radium offers several cmake functions to configure and build your extension.
 
 - \subpage develmeshes
 - \subpage develanimation
+- \subpage develcorematerials
+- \subpage develcorerandom
 
 \page engine Engine
 

doc/developer/corematerials.md

@@ -0,0 +1,24 @@
+\page develcorematerials Core Materials
+[TOC]
+
+A Ra::Core::Material::MaterialModel is a way to control the appearance of an object when rendering.
+
+For now, a Ra::Core::Material::MaterialModel only provides the _Bidirectional Scattering Distribution function (BSDF)_ to be applied on an object.
+
+This _BSDF_ is composed of three methods.
+
+# Methods of the Ra::Core::Material
+
+## Evaluate BSDF
+
+This method, wich is defined as the operator `()` by the interface in Ra::Core::Material::MaterialModel gives the color value of the object for given ingoing, outgoing and surface normal directions.
+
+## Sample BSDF
+
+This method, named `sample()` by the interface in Ra::Core::Material::MaterialModel gives the outgoing direction according to the choosen reflectance model for a given ingoing and surface normal direction.
+
+A Ra::Core::Material::MaterialModel use a Ra::Core::Random::SphereSampler fed with a Ra::Core::Random::UniformGenerator in order to sample. To learn more about samplers and generators, please read the [Random](@ref develcorerandom) section.
+
+## Probability density function corresponding to BSDF
+
+This method, named `pdf()` by the interface in Ra::Core::Material::MaterialModel gives the probability for a pair of ingoing and outgoing direction to exist.

doc/developer/corerandom.md

@@ -0,0 +1,19 @@
+\page develcorerandom Core Random
+[TOC]
+
+The `Ra::Core::Random` namespace contain two interfaces, Ra::Core::Random::UniformGenerator and Ra::Core::Random::SphereSampler.
+
+# Generators
+
+A generator is an implementation of the interface Ra::Core::Random::UniformGenerator. It provides an uniform random distribution between 0 and 1. The interface provides four methods to get a random scalar or a 2D, 3D or nD vector. By default, the vectors are built by calling n times the `get1D()` method.
+
+# Samplers
+
+A sampler follow the interface Ra::Core::Random::SphereSampler. A sphere sampler generate a direction from the center of the sphere to a point on the surface of the sphere according to a probability distribution. To achieve this, it has two methods. A method `getDir()` that maps an uniform generator into the probability distribution to generate a direction in the canonical frame and a method `pdf()` that compute the probability density function value of a direction with a given normal direction (both directions are in world frame).
+
+There is an example app called PlotImportanceSampler that can write samples from several samplers in a json file. The json file can then be read by a python script called plot-samples.py.
+To launch this script do
+
+~~~{.bash}
+python3 /path/to/plot-samples.py /path/to/jsonfile.json
+~~~

examples/CMakeLists.txt

@@ -23,6 +23,7 @@ foreach(
     MaterialEdition
     ParameterEdition
     Picking
+    PlotImportanceSampler
     RawShaderMaterial
     SimpleAnimation
     SimpleSimulation

examples/PlotImportanceSampler/CMakeLists.txt

@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 3.16)
+cmake_policy(SET CMP0042 NEW)
+
+project(PlotImportanceSampler)
+
+# ------------------------------------------------------------------------------
+# set wanted application defaults for cmake settings
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+# Set default install location to installed-<Compiler_ID> folder in build dir we do not want to
+# install to /usr by default
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX
+        "${CMAKE_CURRENT_BINARY_DIR}/installed-${CMAKE_CXX_COMPILER_ID}-${CMAKE_BUILD_TYPE}"
+        CACHE PATH "Install path prefix, prepended onto install directories." FORCE
+    )
+    message("Set install prefix to ${CMAKE_INSTALL_PREFIX}")
+endif()
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_DISABLE_SOURCE_CHANGES ON)
+set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
+
+# ------------------------------------------------------------------------------
+
+find_package(Radium REQUIRED Core)
+
+# ------------------------------------------------------------------------------
+
+set(app_sources main.cpp)
+set(app_headers)
+set(app_resources)
+
+# to install the app as a redistribuable bundle on macos, add MACOSX_BUNDLE when calling
+# add_executable
+add_executable(${PROJECT_NAME} ${app_sources} ${app_headers} ${app_uis} ${app_resources})
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC")
+    target_compile_options(
+        ${PROJECT_NAME}
+        PRIVATE /MP
+                /W4
+                /wd4251
+                /wd4592
+                /wd4127
+                /Zm200
+                $<$<CONFIG:Release>:
+                /Gw
+                /GS-
+                /GL
+                /GF
+                >
+        PUBLIC
+    )
+endif()
+
+target_link_libraries(${PROJECT_NAME} PUBLIC Radium::Core)
+
+# configure the application
+configure_radium_app(NAME ${PROJECT_NAME})

examples/PlotImportanceSampler/main.cpp

@@ -0,0 +1,51 @@
+// Include the samplers and a random generator
+#include <Core/Random/BlinnPhongSphereSampler.hpp>
+#include <Core/Random/CosineWeightedSphereSampler.hpp>
+#include <Core/Random/MersenneTwisterGenerator.hpp>
+#include <Core/Random/UniformSphereSampler.hpp>
+
+#include <fstream>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <vector>
+
+int main( int /*argc*/, char** /*argv*/ ) {
+    using namespace Ra::Core;
+    using json = nlohmann::json;
+
+    //! [Creating the random generator to feed the samplers]
+    Random::MersenneTwisterGenerator generator = Random::MersenneTwisterGenerator();
+
+    //! [Creating the samplers]
+    std::vector<Vector3> uSamplesDir, cSamplesDir, bSamplesDir4, bSamplesDir16, bSamplesDir64,
+        bSamplesDir128;
+
+    //! [Sampling (here 500 times) with each sampler]
+    for ( int i = 0; i < 500; i++ ) {
+        uSamplesDir.push_back( Random::UniformSphereSampler::getDir( &generator ).first );
+        cSamplesDir.push_back( Random::CosineWeightedSphereSampler::getDir( &generator ).first );
+        bSamplesDir4.push_back( Random::BlinnPhongSphereSampler::getDir( &generator, 4 ).first );
+        bSamplesDir16.push_back( Random::BlinnPhongSphereSampler::getDir( &generator, 16 ).first );
+        bSamplesDir64.push_back( Random::BlinnPhongSphereSampler::getDir( &generator, 64 ).first );
+        bSamplesDir128.push_back(
+            Random::BlinnPhongSphereSampler::getDir( &generator, 128 ).first );
+    }
+
+    //! [Creating a json format to write the samples in and write to a file named "samples.json"]
+    json j = { { "UniformSamples", uSamplesDir },
+               { "CosineWeightedSamples", cSamplesDir },
+               { "BlinnPhongSamples 4", bSamplesDir4 },
+               { "BlinnPhongSamples 16", bSamplesDir16 },
+               { "BlinnPhongSamples 64", bSamplesDir64 },
+               { "BlinnPhongSamples 128", bSamplesDir128 } };
+
+    std::ofstream o( "samples.json" );
+
+    o << std::setw( 4 ) << j << std::endl;
+
+    o.close();
+
+    //! [Samples can now be displayed with the python script named "plot-samples.py"]
+
+    return 0;
+}

examples/PlotImportanceSampler/plot-samples.py

@@ -0,0 +1,36 @@
+import json
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import numpy as np
+import math
+import sys
+
+"""
+This python script is used to plot the samples writted to a json file by the main.cpp Radium example app in the PlotImportanceSampler folder.
+
+To launch this script use the command
+python3 plot-samples.py /path/to/jsonfile.json
+"""
+
+def plotDir(array, ax):
+    for p in array:
+        ax.scatter(p[0], p[1], p[2], c='#1f77b4', s=1)
+
+with open(sys.argv[1], 'r') as f:
+    data = json.load(f)
+
+size = len(data)
+
+fig = plt.figure(figsize=plt.figaspect(1/3))
+gs = gridspec.GridSpec(math.ceil(size/3), 3)
+
+i = 0
+for l in data:
+    ax = fig.add_subplot(gs[math.floor(i/3), i%3], projection='3d')
+    ax.set_title(l)
+    ax.set_zlim(0, 1)
+    arr = np.array(data[l])
+    plotDir(arr, ax)
+    i += 1
+
+plt.show()

src/Core/Material/BlinnPhongMaterialModel.cpp

@@ -1,7 +1,8 @@
 #include <Core/Material/BlinnPhongMaterialModel.hpp>
-
 #include <Core/Utils/Log.hpp>
 
+#include <algorithm>
+
 namespace Ra {
 namespace Core {
 namespace Material {
@@ -24,6 +25,80 @@ void BlinnPhongMaterialModel::displayInfo() const {
     print( hasNormalTexture(), " Normal Texture : ", m_texNormal );
     print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
 }
+
+Utils::Color Material::BlinnPhongMaterialModel::operator()( Vector3 w_i,
+                                                            Vector3 w_o,
+                                                            Vector3 normal,
+                                                            Vector2 uv ) {
+    // diffuse lambertien component
+    Utils::Color diffuse = m_kd / M_PI;
+
+    // Blinn-Phong specular component
+    Vector3 halfway = w_i + w_o;
+    halfway.normalize();
+    Scalar specularIntensity =
+        ( m_ns + 2.0f ) / ( 2.0f * M_PI ) * std::pow( normal.dot( halfway ), m_ns );
+    Utils::Color specular = m_ks * specularIntensity;
+
+    // Combine the diffuse and specular components
+    Utils::Color bsdf = diffuse + specular;
+
+    return bsdf;
+}
+
+std::optional<std::pair<Vector3, Scalar>>
+BlinnPhongMaterialModel::sample( Vector3 w_i, Vector3 normal, Vector3 tangent, Vector3 bitangent ) {
+    Vector3 halfway;
+
+    Scalar distrib = m_generator.get()->get1D();
+
+    // diffuse part
+    if ( distrib < m_diffuseLuminance ) {
+        std::pair<Vector3, Scalar> smpl =
+            Core::Random::CosineWeightedSphereSampler::getDir( m_generator.get() );
+        Vector3 wo(
+            smpl.first.dot( tangent ), smpl.first.dot( bitangent ), smpl.first.dot( normal ) );
+        std::pair<Vector3, Scalar> result { wo, smpl.second };
+
+        return result;
+    }
+    // specular part
+    else if ( distrib < m_diffuseLuminance + m_specularLuminance ) {
+        std::pair<Vector3, Scalar> smpl =
+            Core::Random::BlinnPhongSphereSampler::getDir( m_generator.get(), m_ns );
+        Vector3 localMicroFacetNormal = smpl.first;
+        Vector3 microFacetNormal( localMicroFacetNormal.dot( tangent ),
+                                  localMicroFacetNormal.dot( bitangent ),
+                                  localMicroFacetNormal.dot( normal ) );
+        Vector3 reflected = Core::Random::BlinnPhongSphereSampler::reflect( w_i, microFacetNormal );
+        std::pair<Vector3, Scalar> result { reflected, smpl.second };
+
+        return result;
+    }
+    else { // no next dir
+        return {};
+    }
+}
+
+Scalar BlinnPhongMaterialModel::pdf( Vector3 w_i, Vector3 w_o, Vector3 normal ) {
+    return std::clamp( m_diffuseLuminance *
+                               Core::Random::CosineWeightedSphereSampler::pdf( w_o, normal ) +
+                           m_specularLuminance *
+                               Core::Random::BlinnPhongSphereSampler::pdf( w_i, w_o, normal, m_ns ),
+                       0_ra,
+                       1_ra );
+}
+
+void BlinnPhongMaterialModel::computeLuminance() {
+    Vector3 rgbToLuminance { 0.2126_ra, 0.7152_ra, 0.0722_ra };
+    Scalar dIntensity   = m_kd.rgb().dot( rgbToLuminance );
+    Scalar sIntensity   = m_ks.rgb().dot( rgbToLuminance );
+    Scalar diffSpecNorm = std::max( 1_ra, dIntensity + sIntensity );
+
+    m_diffuseLuminance  = dIntensity / diffSpecNorm;
+    m_specularLuminance = sIntensity / diffSpecNorm;
+}
+
 } // namespace Material
 } // namespace Core
 } // namespace Ra