Draft Material in core

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,68 @@
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
+#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;
+
+    Random::MersenneTwisterGenerator generator = Random::MersenneTwisterGenerator();
+
+    std::vector<Vector3> uSamplesDir, cSamplesDir, bSamplesDir4, bSamplesDir16, bSamplesDir64,
+        bSamplesDir128, bpmat, lambmat;
+
+    Material::BlinnPhongMaterialModel bpmaterial = Material::BlinnPhongMaterialModel();
+
+    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 );
+
+        bpmaterial.m_ns = 4;
+        auto sample =
+            bpmaterial.sample( { -1, 0, 1 }, { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 }, { 0, 0 } );
+        if ( sample.has_value() ) bSamplesDir4.push_back( sample.value().first );
+
+        bpmaterial.m_ns = 16;
+        sample = bpmaterial.sample( { -1, 0, 1 }, { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 }, { 0, 0 } );
+        if ( sample.has_value() ) bSamplesDir16.push_back( sample.value().first );
+
+        bpmaterial.m_ns = 64;
+        sample = bpmaterial.sample( { -1, 0, 1 }, { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 }, { 0, 0 } );
+        if ( sample.has_value() ) bSamplesDir64.push_back( sample.value().first );
+
+        bpmaterial.m_ns = 128;
+        sample = bpmaterial.sample( { -1, 0, 1 }, { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 }, { 0, 0 } );
+        if ( sample.has_value() ) bSamplesDir128.push_back( sample.value().first );
+    }
+
+    json j = { //{ "UniformSampleDir", uSamplesDir },
+               //{ "CosineWeightedSampleDir", cSamplesDir },
+               { "BlinnPhongSampleDir 4", bSamplesDir4 },
+               { "BlinnPhongSampleDir 16", bSamplesDir16 },
+               { "BlinnPhongSampleDir 64", bSamplesDir64 },
+               { "BlinnPhongSampleDir 128", bSamplesDir128 } };
+    //    {"BlinnPhongMaterial", bpmat}};
+    //    { "UniformSamplePoint", uSamplesPoint },
+    //    { "CosineWeightedSamplePoint", cSamplesPoint },
+    //    { "BlinnPhongSamplePoint", bSamplesPoint }
+
+    std::ofstream o( "samples.json" );
+
+    o << std::setw( 4 ) << j << std::endl;
+
+    o.close();
+
+    return 0;
+}

examples/PlotImportanceSampler/plot-samples.py

@@ -0,0 +1,29 @@
+import json
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import numpy as np
+import math
+import sys
+
+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,66 @@ void BlinnPhongMaterialModel::displayInfo() const {
     print( hasNormalTexture(), " Normal Texture : ", m_texNormal );
     print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
 }
+Utils::Color Material::BlinnPhongMaterialModel::evalBSDF( 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 inDir,
+                                                                           Vector3 normal,
+                                                                           Vector3 tangent,
+                                                                           Vector3 bitangent,
+                                                                           Vector2 u ) {
+    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 wi(
+            smpl.first.dot( tangent ), smpl.first.dot( bitangent ), smpl.first.dot( normal ) );
+        std::pair<Vector3, Scalar> result { wi, smpl.second };
+        return result;
+    }
+    else if ( distrib < m_diffuseLuminance + m_specularLuminance ) { // specular part
+        std::pair<Vector3, Scalar> smpl =
+            Core::Random::BlinnPhongSphereSampler::getDir( m_generator.get(), m_ns );
+        Vector3 wi(
+            smpl.first.dot( tangent ), smpl.first.dot( bitangent ), smpl.first.dot( normal ) );
+        std::pair<Vector3, Scalar> result { wi, smpl.second };
+        return result;
+    }
+    else { // no next dir
+        return {};
+    }
+}
+
+Scalar BlinnPhongMaterialModel::PDF( Vector3 inDir, Vector3 outDir, Vector3 normal ) {
+    return std::clamp( m_diffuseLuminance *
+                               Core::Random::CosineWeightedSphereSampler::pdf( outDir, normal ) +
+                           m_specularLuminance *
+                               Core::Random::BlinnPhongSphereSampler::pdf( outDir, normal, m_ns ),
+                       0_ra,
+                       1_ra );
+}
+
 } // namespace Material
 } // namespace Core
 } // namespace Ra

src/Core/Material/BlinnPhongMaterialModel.hpp

@@ -1,50 +1,100 @@
 #pragma once
 
-#include <Core/Material/MaterialModel.hpp>
+#include <Core/Material/SimpleMaterialModel.hpp>
+#include <Core/Random/BlinnPhongSphereSampler.hpp>
+#include <Core/Random/UniformGenerator.hpp>
 #include <Core/Utils/Color.hpp>
 
+#include <ctime>
+
 namespace Ra {
 namespace Core {
 namespace Material {
 
 // RADIUM SUPPORTED MATERIALS
-class RA_CORE_API BlinnPhongMaterialModel : public MaterialModel
+class RA_CORE_API BlinnPhongMaterialModel : public SimpleMaterialModel
 {
   public:
-    explicit BlinnPhongMaterialModel( const std::string& name = "" ) :
-        MaterialModel( name, "BlinnPhong" ) {}
+    explicit BlinnPhongMaterialModel(
+        const std::string& name = "",
+        std::shared_ptr<Core::Random::UniformGenerator> generator =
+            std::make_shared<Core::Random::MersenneTwisterGenerator>() ) :
+        SimpleMaterialModel( name, "BlinnPhong", generator ) {}
+
     ~BlinnPhongMaterialModel() override = default;
 
     /// DEBUG
     void displayInfo() const override;
 
     /// QUERY
 
-    bool hasDiffuseTexture() const { return m_hasTexDiffuse; }
-
     bool hasSpecularTexture() const { return m_hasTexSpecular; }
 
     bool hasShininessTexture() const { return m_hasTexShininess; }
 
     bool hasNormalTexture() const { return m_hasTexNormal; }
 
-    bool hasOpacityTexture() const { return m_hasTexOpacity; }
+    Utils::Color evalBSDF( Vector3 w_i, Vector3 w_o, Vector3 normal, Vector2 uv ) override;
+    std::optional<std::pair<Vector3, Scalar>>
+    sample( Vector3 inDir, Vector3 normal, Vector3 tangent, Vector3 bitangent, Vector2 u ) override;
+    Scalar PDF( Vector3 inDir, Vector3 outDir, Vector3 normal ) override;
+
+    inline Utils::Color getSpecularColor() const { return m_ks; }
+    inline Scalar getShininess() const { return m_ns; }
+    inline Scalar getDiffuseLuminance() const { return m_diffuseLuminance; }
+    inline Scalar getSpecularLuminance() const { return m_specularLuminance; }
+    inline std::string getTexSpecular() const { return m_texSpecular; }
+    inline std::string getTexShininess() const { return m_texShininess; }
+    inline std::string getTexNormal() const { return m_texNormal; }
+
+    inline void setDiffuseColor( Utils::Color color ) {
+        m_kd = color;
+        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 /= diffSpecNorm;
+        m_specularLuminance /= diffSpecNorm;
+        m_alpha = color.alpha();
+    }
+
+    inline void setSpecularColor( Utils::Color color ) {
+        m_ks = color;
+        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 /= diffSpecNorm;
+        m_specularLuminance /= diffSpecNorm;
+    }
+
+    inline void setShininess( Scalar specular ) { m_ns = specular; }
+    inline void setTexSpecular( std::string texSpecular ) {
+        m_texSpecular    = texSpecular;
+        m_hasTexSpecular = true;
+    }
+    inline void setTexShininess( std::string texShininess ) {
+        m_texShininess    = texShininess;
+        m_hasTexShininess = true;
+    }
+    inline void setTexNormal( std::string texNormal ) {
+        m_texNormal    = texNormal;
+        m_hasTexNormal = true;
+    }
 
-    /// DATA MEMBERS
-    Core::Utils::Color m_kd { 0.7_ra, 0.7_ra, 0.7_ra };
+  private:
     Core::Utils::Color m_ks { 0.3_ra, 0.3_ra, 0.3_ra };
     Scalar m_ns { 64_ra };
-    Scalar m_alpha { 1_ra };
-    std::string m_texDiffuse;
+    Scalar m_diffuseLuminance;
+    Scalar m_specularLuminance;
     std::string m_texSpecular;
     std::string m_texShininess;
     std::string m_texNormal;
-    std::string m_texOpacity;
-    bool m_hasTexDiffuse { false };
     bool m_hasTexSpecular { false };
     bool m_hasTexShininess { false };
     bool m_hasTexNormal { false };
-    bool m_hasTexOpacity { false };
 };
 
 } // namespace Material

src/Core/Material/MaterialModel.cpp

@@ -1,3 +1,4 @@
+#include "MaterialModel.hpp"
 #include <Core/Material/MaterialModel.hpp>
 #include <Core/Utils/Log.hpp>
 
@@ -8,6 +9,7 @@ void MaterialModel::displayInfo() const {
     using namespace Core::Utils; // log
     LOG( logERROR ) << "MaterialModel : unknown material type : " << m_materialType;
 }
+
 } // namespace Material
 } // namespace Core
 } // namespace Ra