ProcessedSample + member m_specular_strategy, yet unused

Resample/Processed/ProcessedSample.cpp

@@ -220,6 +220,14 @@ ProcessedSample ProcessedSample::make(const MultiLayer& sample, const Simulation
     const SliceStack refined_stack =
         options.useAvgMaterials() ? refineStack(slices1, layouts) : slices1;
 
+    std::unique_ptr<const ISpecularStrategy> specular_strategy;
+    if (slices1.containsMagneticMaterial())
+         specular_strategy =
+            SampleUtils::SpecularStrategyBuilder::buildMagnetic(sample.roughnessModel());
+    else
+         specular_strategy =
+            SampleUtils::SpecularStrategyBuilder::buildScalar(sample.roughnessModel());
+
     std::unique_ptr<const IFresnelMap> fresnel_map;
     if (slices1.containsMagneticMaterial())
         fresnel_map = std::make_unique<const MatrixFresnelMap>(
@@ -231,23 +239,26 @@ ProcessedSample ProcessedSample::make(const MultiLayer& sample, const Simulation
             SampleUtils::SpecularStrategyBuilder::buildScalar(sample.roughnessModel()));
 
     return ProcessedSample(sample, polarized, std::move(layouts), refined_stack,
-                           fresnel_map.release());
+                           specular_strategy.release(), fresnel_map.release());
 }
 
 ProcessedSample::ProcessedSample(const MultiLayer& sample, bool polarized,
                                  std::vector<ProcessedLayout>&& layouts,
-                                 const SliceStack& refined_stack, const IFresnelMap* fresnel_map)
+                                 const SliceStack& refined_stack,
+                                 const ISpecularStrategy* specular_strategy,
+                                 const IFresnelMap* fresnel_map)
     : m_sample(sample)
     , m_polarized(polarized)
     , m_layouts(std::move(layouts))
     , m_refined_stack(refined_stack)
+    , m_specular_strategy(specular_strategy)
     , m_fresnel_map(fresnel_map)
 {
 }
 
 ProcessedSample::ProcessedSample(ProcessedSample&&)
     : ProcessedSample(m_sample, m_polarized, std::move(m_layouts), m_refined_stack,
-                      m_fresnel_map.release())
+                      m_specular_strategy.release(), m_fresnel_map.release())
 {
 }
 

Resample/Processed/ProcessedSample.h

@@ -26,6 +26,7 @@
 #include <vector>
 
 class IFresnelMap;
+class ISpecularStrategy;
 class Material;
 class MultiLayer;
 class ProcessedLayout;
@@ -63,11 +64,13 @@ public:
 private:
     ProcessedSample(const MultiLayer& sample, bool polarized,
                     std::vector<ProcessedLayout>&& layouts, const SliceStack& refined_stack,
+                    const ISpecularStrategy* specular_strategy,
                     const IFresnelMap* fresnel_map);
     const MultiLayer& m_sample;
     const bool m_polarized;
     std::vector<ProcessedLayout> m_layouts; // const forbidden by &&-c'tor < needed by tests
     const SliceStack m_refined_stack;
+    std::unique_ptr<const ISpecularStrategy> m_specular_strategy;
     std::unique_ptr<const IFresnelMap> m_fresnel_map;
 };