fix(tsd, rtx): Drop distinlling, improve PTX stitching, CMake

devices/rtx/device/material/shaders/MDLShader_ptx.cu

@@ -47,11 +47,11 @@ using BsdfInitFunc = mi::neuraylib::Bsdf_init_function;
 using BsdfSampleFunc = mi::neuraylib::Bsdf_sample_function;
 using BsdfEvaluateFunc = mi::neuraylib::Bsdf_evaluate_function;
 using BsdfPdfFunc = mi::neuraylib::Bsdf_pdf_function;
+using BsdfAuxiliaryFunc = mi::neuraylib::Bsdf_auxiliary_function;
 
 using EdfEvaluateFunc = mi::neuraylib::Edf_evaluate_function;
 
 //
-using TintExprFunc = mi::neuraylib::Material_function<vec3>::Type;
 using OpacityExprFunc = mi::neuraylib::Material_function<float>::Type;
 using TransmissionExprFunc = mi::neuraylib::Material_function<vec3>::Type;
 using EmissionIntensityExprFunc = mi::neuraylib::Material_function<vec3>::Type;
@@ -63,6 +63,8 @@ using BsdfSampleData = mi::neuraylib::Bsdf_sample_data;
 using BsdfEvaluateData =
     mi::neuraylib::Bsdf_evaluate_data<mi::neuraylib::DF_HSM_NONE>;
 using BsdfPdfData = mi::neuraylib::Bsdf_pdf_data;
+using BsdfAuxiliaryData =
+    mi::neuraylib::Bsdf_auxiliary_data<mi::neuraylib::DF_HSM_NONE>;
 
 using BsdfIsThinWalled = bool(
     const ShadingStateMaterial *, const ResourceData *, const char *);
@@ -71,9 +73,9 @@ VISRTX_CALLABLE BsdfInitFunc mdlInit;
 VISRTX_CALLABLE BsdfSampleFunc mdlBsdf_sample;
 VISRTX_CALLABLE BsdfEvaluateFunc mdlBsdf_evaluate;
 VISRTX_CALLABLE BsdfPdfFunc mdlBsdf_pdf;
+VISRTX_CALLABLE BsdfAuxiliaryFunc mdlBsdf_auxiliary;
 VISRTX_CALLABLE BsdfIsThinWalled mdl_isThinWalled;
 
-VISRTX_CALLABLE TintExprFunc mdlTint;
 VISRTX_CALLABLE OpacityExprFunc mdlOpacity;
 VISRTX_CALLABLE TransmissionExprFunc mdlTransmission;
 VISRTX_CALLABLE EdfEvaluateFunc mdlEmission_evaluate;
@@ -241,11 +243,24 @@ NextRay __direct_callable__nextRay(
 }
 
 // Signature must match the call inside shaderMDLSurface in MDLShader.cuh.
+// Base color for the albedo AOV / denoiser guide: the BSDF auxiliary albedo
+// (diffuse + glossy) from the compiled material. Evaluated at normal incidence
+// (k1 = shading normal) so the guide is view-independent and stable across
+// samples.
 VISRTX_CALLABLE
 vec3 __direct_callable__evaluateTint(const MDLShadingState *shadingState)
 {
-  return mdlTint(
-      &shadingState->state, &shadingState->resData, shadingState->argBlock);
+  BsdfAuxiliaryData aux_data = {};
+  aux_data.ior1 = make_float3(1.0f, 1.0f, 1.0f);
+  aux_data.ior2.x = MI_NEURAYLIB_BSDF_USE_MATERIAL_IOR;
+  aux_data.k1 = shadingState->state.normal;
+
+  mdlBsdf_auxiliary(&aux_data,
+      &shadingState->state,
+      &shadingState->resData,
+      shadingState->argBlock);
+
+  return make_vec3(aux_data.albedo_diffuse) + make_vec3(aux_data.albedo_glossy);
 }
 
 VISRTX_CALLABLE

devices/rtx/libmdl/Core.cpp

@@ -23,7 +23,6 @@
 #include <mi/neuraylib/imdl_backend_api.h>
 #include <mi/neuraylib/imdl_compiler.h>
 #include <mi/neuraylib/imdl_configuration.h>
-#include <mi/neuraylib/imdl_distiller_api.h>
 #include <mi/neuraylib/imdl_entity_resolver.h>
 #include <mi/neuraylib/imdl_execution_context.h>
 #include <mi/neuraylib/imdl_factory.h>
@@ -159,13 +158,6 @@ Core::Core(mi::neuraylib::INeuray *neuray, mi::base::ILogger *logger)
           mi::base::MESSAGE_SEVERITY_WARNING, "Failed to load the dds plugin");
     }
 
-    if (mi::Sint32 res = pluginConf->load_plugin_library(
-            "mdl_distiller" MI_BASE_DLL_FILE_EXT);
-        res != 0) {
-      logMessage(mi::base::MESSAGE_SEVERITY_WARNING,
-          "Failed to load the mdl_distiller plugin");
-    }
-
     m_neuray->start();
   }
 
@@ -489,23 +481,6 @@ mi::neuraylib::ICompiled_material *Core::getCompiledMaterial(
   return compiledMaterial;
 }
 
-mi::neuraylib::ICompiled_material *Core::getDistilledToDiffuse(
-    const mi::neuraylib::ICompiled_material *compiledMaterial)
-{
-  auto distiller_api = make_handle(
-      m_neuray->get_api_component<mi::neuraylib::IMdl_distiller_api>());
-  mi::Sint32 result = 0;
-  auto distilledMaterial = distiller_api->distill_material(
-      compiledMaterial, "diffuse", nullptr, &result);
-  if (result != 0) {
-    logMessage(mi::base::MESSAGE_SEVERITY_ERROR,
-        "Failed to distill material: %i\n",
-        result);
-  }
-
-  return distilledMaterial;
-}
-
 const mi::neuraylib::ITarget_code *Core::getPtxTargetCode(
     const mi::neuraylib::ICompiled_material *compiledMaterial,
     mi::neuraylib::ITransaction *transaction)
@@ -518,8 +493,6 @@ const mi::neuraylib::ITarget_code *Core::getPtxTargetCode(
   auto executionContext =
       make_handle(m_mdlFactory->clone(m_executionContext.get()));
 
-  auto distilledMaterial = make_handle(getDistilledToDiffuse(compiledMaterial));
-
   ptxBackend->set_option(
       "num_texture_spaces", std::to_string(kNumTextureSpaces).c_str());
   ptxBackend->set_option(
@@ -534,6 +507,10 @@ const mi::neuraylib::ITarget_code *Core::getPtxTargetCode(
   ptxBackend->set_option("inline_aggressively", "on");
   ptxBackend->set_option("opt_level", "2");
   ptxBackend->set_option("enable_exceptions", "off");
+  // Generate the BSDF auxiliary function (albedo + normal) so the albedo AOV /
+  // denoiser guide reads a faithful diffuse+glossy albedo straight from the
+  // compiled material, instead of distilling to a `diffuse` proxy.
+  ptxBackend->set_option("enable_auxiliary", "on");
 
   // Generate init, surface scattering, surface emission
   // (emission/intensity/mode), volume scattering and cutout opacity.
@@ -551,16 +528,13 @@ const mi::neuraylib::ITarget_code *Core::getPtxTargetCode(
       {"geometry.cutout_opacity", "mdlOpacity"},
   };
 
-  static mi::neuraylib::Target_function_description distilledFunctions[] = {
-      {"surface.scattering.tint", "mdlTint"},
-  };
-
   // Generate target code for the compiled material
   auto linkUnit = make_handle(
       ptxBackend->create_link_unit(transaction, executionContext.get()));
 
-  // Add main material functions (BSDF, emission, and auxiliary
-  // albedo/normal/roughness)
+  // Add main material functions. `surface.scattering` also emits the BSDF
+  // auxiliary function (mdlBsdf_auxiliary: albedo + normal) because
+  // enable_auxiliary is on.
   linkUnit->add_material(compiledMaterial,
       std::data(materialFunctions),
       std::size(materialFunctions),
@@ -569,14 +543,6 @@ const mi::neuraylib::ITarget_code *Core::getPtxTargetCode(
   if (!logExecutionContextMessages(executionContext.get()))
     return {};
 
-  linkUnit->add_material(distilledMaterial.get(),
-      std::data(distilledFunctions),
-      std::size(distilledFunctions),
-      executionContext.get());
-
-  if (!logExecutionContextMessages(executionContext.get()))
-    return {};
-
   auto targetCode =
       ptxBackend->translate_link_unit(linkUnit.get(), executionContext.get());
   if (!logExecutionContextMessages(executionContext.get()))

devices/rtx/libmdl/Core.h

@@ -134,9 +134,6 @@ class Core
       const mi::neuraylib::IFunction_definition *,
       bool classCompilation = true);
 
-  mi::neuraylib::ICompiled_material *getDistilledToDiffuse(
-      const mi::neuraylib::ICompiled_material *compiledMaterial);
-
   const mi::neuraylib::ITarget_code *getPtxTargetCode(
       const mi::neuraylib::ICompiled_material *compiledMaterial,
       mi::neuraylib::ITransaction *transaction);