[C API][Unreal] Adds the support for visualization of real time reflection ray tracing

core/src/core/api_simulator.cpp

@@ -144,6 +144,7 @@ void CSimulator::setSharedInputs(IPLSimulationFlags flags,
         sharedReflectionInputs.order = sharedData->order;
         sharedReflectionInputs.irradianceMinDistance = sharedData->irradianceMinDistance;
         sharedReflectionInputs.reconstructionType = ReconstructionType::Linear;
+        sharedReflectionInputs.reflectionVisualization = sharedData->reflectionVisualization;
 
         _simulator->setSharedReflectionInputs(sharedReflectionInputs);
     }
@@ -162,6 +163,26 @@ void CSimulator::setSharedInputs(IPLSimulationFlags flags,
     }
 }
 
+void CSimulator::getSharedOutputs(IPLSimulationFlags flags,
+                                  IPLSimulationSharedOutputs& sharedOutputs)
+{
+    auto _simulator = mHandle.get();
+    if (!_simulator)
+        return;
+
+    if (flags & IPL_SIMULATIONFLAGS_REFLECTIONS)
+    {
+        SharedReflectionSimulationOutputs reflectionOutputs;
+        _simulator->getSharedReflectionOutputs(reflectionOutputs);
+
+        int numReflectionRays = reflectionOutputs.reflectionRays.size() < 128 ? reflectionOutputs.reflectionRays.size() : 128;
+        for (int i = 0; i < numReflectionRays; ++i)
+        {
+            sharedOutputs.reflectionRays[i] = reflectionOutputs.reflectionRays[numReflectionRays < 128 ? i : (reflectionOutputs.reflectionRays.size() - 1) / (i + 1)].data();
+        }
+    }
+}
+
 void CSimulator::commit()
 {
     auto _simulator = mHandle.get();

core/src/core/api_simulator.h

@@ -58,6 +58,9 @@ class CSimulator : public ISimulator
     virtual void setSharedInputs(IPLSimulationFlags flags,
                                  IPLSimulationSharedInputs* sharedInputs) override;
 
+    virtual void getSharedOutputs(IPLSimulationFlags flags,
+                                IPLSimulationSharedOutputs& sharedOutputs) override;
+
     virtual void commit() override;
 
     virtual void runDirect() override;

core/src/core/embree_reflection_simulator.h

@@ -65,6 +65,7 @@ class EmbreeReflectionSimulator : public IReflectionSimulator
                           float duration,
                           int order,
                           float irradianceMinDistance,
+                          vector<vector<IPLRay>>* reflectionRays,
                           EnergyField* const* energyFields,
                           JobGraph& jobGraph) override;
 

core/src/core/phonon.h

@@ -4099,8 +4099,19 @@ typedef struct {
     /** Pointer to arbitrary user-specified data provided when calling the function that will
         call this callback.*/
     void* pathingUserData;
+
+    /** Is need to visualize reflection */
+    IPLbool reflectionVisualization;
 } IPLSimulationSharedInputs;
 
+/** Simulation results that are not specific to any source. */
+typedef struct {
+
+    /** Several reflection rays that are used for reflection visualization.*/
+    IPLRay* reflectionRays[128];
+
+} IPLSimulationSharedOutputs;
+
 /** Simulation results for a source. */
 typedef struct {
     /** Direct path simulation results. */
@@ -4184,6 +4195,14 @@ IPLAPI void IPLCALL iplSimulatorRemoveProbeBatch(IPLSimulator simulator, IPLProb
 */
 IPLAPI void IPLCALL iplSimulatorSetSharedInputs(IPLSimulator simulator, IPLSimulationFlags flags, IPLSimulationSharedInputs* sharedInputs);
 
+/** Returns simulation parameters that are not associated with any particular source.
+
+    \param  simulator       The simulator being used.
+    \param  flags           The types of simulation for which to specify shared outputs.
+    \param  sharedOutputs    The shared outputs parameters to get.
+*/
+IPLAPI void IPLCALL iplSimulatorGetSharedOutputs(IPLSimulator simulator, IPLSimulationFlags flags, IPLSimulationSharedOutputs& sharedOutputs);
+
 /** Commits changes to the scene or probe batches used for simulation.
 
     Call this function after calling \c iplSimulatorSetScene, \c iplSimulatorAddProbeBatch, or

core/src/core/phonon_interfaces.h

@@ -613,6 +613,9 @@ class ISimulator
     virtual void setSharedInputs(IPLSimulationFlags flags,
                                  IPLSimulationSharedInputs* sharedInputs) = 0;
 
+    virtual void getSharedOutputs(IPLSimulationFlags flags,
+                                IPLSimulationSharedOutputs& sharedInputs) = 0;
+
     virtual void commit() = 0;
 
     virtual void runDirect() = 0;
@@ -2338,6 +2341,16 @@ void IPLCALL iplSimulatorSetSharedInputs(IPLSimulator simulator,
     reinterpret_cast<api::ISimulator*>(simulator)->setSharedInputs(flags, sharedInputs);
 }
 
+void IPLCALL iplSimulatorGetSharedOutputs(IPLSimulator simulator, 
+                                    IPLSimulationFlags flags, 
+                                    IPLSimulationSharedOutputs& sharedOutputs)
+{
+    if (!simulator)
+        return;
+
+    reinterpret_cast<api::ISimulator*>(simulator)->getSharedOutputs(flags, sharedOutputs);
+}
+
 void IPLCALL iplSimulatorCommit(IPLSimulator simulator)
 {
     if (!simulator)

core/src/core/radeonrays_reflection_simulator.h

@@ -67,6 +67,7 @@ class RadeonRaysReflectionSimulator : public IReflectionSimulator
                           float duration,
                           int order,
                           float irradianceMinDistance,
+                          vector<vector<IPLRay>>* reflectionRays,
                           EnergyField* const* energyFields,
                           JobGraph& jobGraph) override;
 

core/src/core/ray.h

@@ -21,6 +21,7 @@
 #include "mesh.h"
 #include "sphere.h"
 #include "triangle.h"
+#include "phonon.h"
 
 namespace ipl {
 
@@ -56,6 +57,14 @@ class Ray
 
     // Calculates the intersection of a ray with a sphere.
     float intersect(const Sphere& sphere) const;
+
+    operator IPLRay()
+    {
+        IPLRay iplRay;
+        iplRay.direction = { direction.x(), direction.y(), direction.z() };
+        iplRay.origin = { origin.x(), origin.y(), origin.z() };
+        return iplRay;
+    }
 };
 
 }

core/src/core/reflection_baker.cpp

@@ -154,7 +154,7 @@ void ReflectionBaker::bake(const IScene& scene,
             jobGraph.reset();
             simulator.simulate(scene, numSources, sources.data(), numListeners, listeners.data(),
                                directivities.data(), numRays, numBounces, simDuration, order,
-                               irradianceMinDistance, energyFieldPtrs.data(), jobGraph);
+                               irradianceMinDistance, nullptr, energyFieldPtrs.data(), jobGraph);
 
             threadPool.process(jobGraph);
 

core/src/core/reflection_simulator.cpp

@@ -153,6 +153,7 @@ void ReflectionSimulator::simulate(const IScene& scene,
                                    float duration,
                                    int order,
                                    float irradianceMinDistance,
+                                   vector<vector<IPLRay>>* reflectionRays,
                                    EnergyField* const* energyFields,
                                    JobGraph& jobGraph)
 {
@@ -180,6 +181,10 @@ void ReflectionSimulator::simulate(const IScene& scene,
     mDuration = duration;
     mOrder = order;
     mIrradianceMinDistance = irradianceMinDistance;
+    if (reflectionRays)
+    {
+        mReflectionRays = reflectionRays; mReflectionRays->resize(mNumRays);
+    }
 
     for (auto i = 0; i < numSources; ++i)
     {
@@ -375,7 +380,26 @@ void ReflectionSimulator::simulateJob(const IScene& scene,
             Hit hit;
             Vector3f hitPoint;
             if (!trace(scene, ray, j, accumDistance, hit, hitPoint))
+            {
                 break;
+            }
+
+            // Reflection visualization code start
+            if (mReflectionRays)
+            {
+                (*mReflectionRays)[i].size() <= 0 ? (*mReflectionRays)[i].resize(mNumBounces + 1) : 0;
+                if (j == 0)
+                {
+                    (*mReflectionRays)[i][j] = Ray{ ray.origin, ray.direction * hit.distance };
+                }
+                else
+                {
+                    IPLVector3 iplDirection = (*mReflectionRays)[i][j].direction;
+                    Vector3f direction = Vector3f(iplDirection.x, iplDirection.y, iplDirection.z) * hit.distance;
+                    (*mReflectionRays)[i][j].direction = { direction.x(), direction.y(), direction.z() };
+                }
+            }
+            // Reflection visualization code end
 
             if (cancel)
                 return;
@@ -410,6 +434,18 @@ void ReflectionSimulator::simulateJob(const IScene& scene,
             {
                 bounce(scene, j, hit, hitPoint, threadId, ray, accumEnergy, accumDistance);
 
+                // Reflection visualization code start
+                if (mReflectionRays)
+                if (j == (*mReflectionRays)[i].size() - 1)
+                {
+                    (*mReflectionRays)[i][j + 1] = Ray{ ray.origin, ray.direction * scene.closestHit(ray, 0.0f, std::numeric_limits<float>::infinity()).distance };
+                }
+                else
+                {
+                    (*mReflectionRays)[i][j + 1] = ray;
+                }
+                // Reflection visualization code end
+
                 if (cancel)
                     return;
             }
@@ -676,18 +712,19 @@ void BatchedReflectionSimulator::simulate(const IScene& scene,
 }
 
 void BatchedReflectionSimulator::simulate(const IScene& scene,
-                                          int numSources,
-                                          const CoordinateSpace3f* sources,
-                                          int numListeners,
-                                          const CoordinateSpace3f* listeners,
-                                          const Directivity* directivities,
-                                          int numRays,
-                                          int numBounces,
-                                          float duration,
-                                          int order,
-                                          float irradianceMinDistance,
-                                          EnergyField* const* energyFields,
-                                          JobGraph& jobGraph)
+                                   int numSources,
+                                   const CoordinateSpace3f* sources,
+                                   int numListeners,
+                                   const CoordinateSpace3f* listeners,
+                                   const Directivity* directivities,
+                                   int numRays,
+                                   int numBounces,
+                                   float duration,
+                                   int order,
+                                   float irradianceMinDistance,
+                                   vector<vector<IPLRay>>* reflectionRays,
+                                   EnergyField* const* energyFields,
+                                   JobGraph& jobGraph)
 {
     PROFILE_FUNCTION();
 

core/src/core/reflection_simulator.h

@@ -21,6 +21,7 @@
 #include "job_graph.h"
 #include "sampling.h"
 #include "scene.h"
+#include "phonon.h"
 
 namespace ipl {
 
@@ -66,6 +67,7 @@ class IReflectionSimulator
                           float duration,
                           int order,
                           float irradianceMinDistance,
+                          vector<vector<IPLRay>>* reflectionRays,
                           EnergyField* const* energyFields,
                           JobGraph& jobGraph) = 0;
 
@@ -130,6 +132,7 @@ class ReflectionSimulator : public IReflectionSimulator
                           float duration,
                           int order,
                           float irradianceMinDistance,
+                          vector<vector<IPLRay>>* reflectionRays,
                           EnergyField* const* energyFields,
                           JobGraph& jobGraph) override;
 
@@ -177,6 +180,7 @@ class ReflectionSimulator : public IReflectionSimulator
     Array<float, 2> mListenerCoeffs;
     std::atomic<int> mNumJobsRemaining;
     Array<ThreadState> mThreadState;
+    vector<vector<IPLRay>>* mReflectionRays = nullptr;
 
     void simulateJob(const IScene& scene,
                      Array<float, 2>& image,
@@ -263,6 +267,7 @@ class BatchedReflectionSimulator : public IReflectionSimulator
                           float duration,
                           int order,
                           float irradianceMinDistance,
+                          vector<vector<IPLRay>>* reflectionRays,
                           EnergyField* const* energyFields,
                           JobGraph& jobGraph) override;
 

core/src/core/simulation_manager.cpp

@@ -260,22 +260,23 @@ void SimulationManager::simulateIndirect()
 void SimulationManager::simulateRealTimeReflections()
 {
     PROFILE_FUNCTION();
-
+    
     mRealTimeSources.clear();
     mRealTimeDirectivities.clear();
     mRealTimeEnergyFields.clear();
+    mSharedData->reflectionOutputs.reflectionRays.clear();
 
     auto listenerChanged = hasListenerChanged();
     auto sceneChanged = hasSceneChanged();
-
+    
     for (auto& source : mSourceData[0])
     {
         if (!source->reflectionInputs.enabled)
             continue;
 
         if (source->reflectionInputs.baked)
             continue;
-
+        
         mRealTimeSources.push_back(source->reflectionInputs.source);
         mRealTimeDirectivities.push_back(source->reflectionInputs.directivity);
 
@@ -291,19 +292,20 @@ void SimulationManager::simulateRealTimeReflections()
             mRealTimeEnergyFields.push_back(source->reflectionState.energyField.get());
         }
     }
-
+    
     if (mRealTimeSources.empty())
         return;
 
     mJobGraph.reset();
-
+
+    auto reflectionRaysPtr = mSharedData->reflection.reflectionVisualization ? &mSharedData->reflectionOutputs.reflectionRays : nullptr;
     mReflectionSimulator->simulate(*mScene, static_cast<int>(mRealTimeSources.size()), mRealTimeSources.data(), 1, &mSharedData->reflection.listener,
                                    mRealTimeDirectivities.data(), mSharedData->reflection.numRays, mSharedData->reflection.numBounces,
                                    mSharedData->reflection.duration, mSharedData->reflection.order, mSharedData->reflection.irradianceMinDistance,
-                                   mRealTimeEnergyFields.data(), mJobGraph);
+                                   reflectionRaysPtr, mRealTimeEnergyFields.data(), mJobGraph);
 
     mThreadPool->process(mJobGraph);
-
+    
     accumulateEnergyFields();
 }
 

core/src/core/simulation_manager.h

@@ -52,6 +52,7 @@ struct SharedReflectionSimulationInputs
     int order;
     float irradianceMinDistance;
     ReconstructionType reconstructionType;
+    bool reflectionVisualization;
 };
 
 struct SharedPathingSimulationInputs
@@ -61,11 +62,17 @@ struct SharedPathingSimulationInputs
     void* userData = nullptr;
 };
 
+struct SharedReflectionSimulationOutputs
+{
+    vector<vector<IPLRay>> reflectionRays;
+};
+
 struct SharedSimulationData
 {
     SharedDirectSimulationInputs direct;
     SharedReflectionSimulationInputs reflection;
     SharedPathingSimulationInputs pathing;
+    SharedReflectionSimulationOutputs reflectionOutputs;
 };
 
 class SimulationManager
@@ -166,6 +173,19 @@ class SimulationManager
         mSharedData->pathing = sharedPathingInputs;
     }
 
+    void getSharedReflectionOutputs(SharedReflectionSimulationOutputs& sharedReflectionOutputs)
+    {
+        sharedReflectionOutputs.reflectionRays.resize(mSharedData->reflectionOutputs.reflectionRays.size());
+        for (int i = 0; i < sharedReflectionOutputs.reflectionRays.size(); ++i)
+        {
+            sharedReflectionOutputs.reflectionRays[i].resize(mSharedData->reflectionOutputs.reflectionRays[i].size());
+            for (int j = 0; j < sharedReflectionOutputs.reflectionRays[i].size(); ++j)
+            {
+                sharedReflectionOutputs.reflectionRays[i][j] = mSharedData->reflectionOutputs.reflectionRays[i][j];
+            }
+        }
+    }
+
     void addProbeBatch(shared_ptr<ProbeBatch> probeBatch);
 
     void removeProbeBatch(shared_ptr<ProbeBatch> probeBatch);