Merge pull request #144 from beasterio/baikal-next

fix linux build + merge with rpr branch + TileRender + AOV

Author: yozhijk

App/App.lua

@@ -18,7 +18,7 @@ project "App"
     if os.is("windows") then
         includedirs { "../3rdparty/glew/include", "../3rdparty/freeglut/include",
         "../3rdparty/oiio/include", "../3rdparty/glfw/include"}
-        links {"RadeonRays"}
+        links {"RadeonRays", "glfw3"}
         if not _OPTIONS["benchmark"] then
             links {"glew", "OpenGL32", "glfw3"}
         end
@@ -39,7 +39,7 @@ project "App"
         buildoptions "-std=c++11"
         links {"OpenImageIO", "pthread"}
         if not _OPTIONS["benchmark"] then
-            links{"GLEW", "GL", "glfw3"}
+            links{"GLEW", "GL", "glfw"}
         end
         os.execute("rm -rf obj");
     end
@@ -70,7 +70,7 @@ project "App"
     if _OPTIONS["benchmark"] then
         defines{"APP_BENCHMARK"}
         removefiles{"../App/main.cpp",
-                    "../App/shader_manager.cpp",}
+                    "../App/Utils/shader_manager.cpp",}
     else
         removefiles {"../App/main_benchmark.cpp"}
     end

App/CL/bxdf.cl

@@ -26,7 +26,7 @@ THE SOFTWARE.
 #include <../App/CL/texture.cl>
 #include <../App/CL/payload.cl>
 
-#define DENOM_EPS 0.0f
+#define DENOM_EPS 1e-8f
 #define ROUGHNESS_EPS 0.0001f
 
 
@@ -338,7 +338,12 @@ float3 MicrofacetGGX_Evaluate(
     float denom = (4.f * costhetao * costhetai);
 
     // F(eta) * D * G * ks / (4 * cosa * cosi)
-    return denom > 0.f ? F * ks * MicrofacetDistribution_GGX_G(roughness, wi, wo, wh) * MicrofacetDistribution_GGX_D(roughness, wh) / denom : 0.f;
+    //return denom > 0.f ? F * ks * MicrofacetDistribution_GGX_G(roughness, wi, wo, wh) * MicrofacetDistribution_GGX_D(roughness, wh) / denom : 0.f;
+    
+    float3 res = denom > 0.f ? F * ks * MicrofacetDistribution_GGX_G(roughness, wi, wo, wh) * MicrofacetDistribution_GGX_D(roughness, wh) / denom : 0.f;
+    if (length(res) < 0.1f)
+        res = 0.f;
+    return res;
 }
 
 

App/Core/renderer.h

@@ -128,6 +128,8 @@ namespace Baikal
             float primary_rays_time_in_ms;
             float secondary_rays_time_in_ms;
             float shadow_rays_time_in_ms;
+            //msamples per second
+            float samples_pes_sec;
         };
 
         virtual void RunBenchmark(Scene1 const& scene, std::uint32_t num_passes, BenchmarkStats& stats) {}

App/Renderers/PT/ptrenderer.cpp

@@ -866,5 +866,16 @@ namespace Baikal
 
         //
         m_context.Flush(0);
+
+        //samples statisticks
+        output->Clear(0.f);
+        start = std::chrono::high_resolution_clock::now();
+        for (auto i = 0U; i < num_passes; ++i)
+        {
+            Render(scene);
+        }
+        delta = std::chrono::high_resolution_clock::now() - start;
+
+        stats.samples_pes_sec = output->width() * output->height() / ((float)std::chrono::duration_cast<std::chrono::milliseconds>(delta).count() / num_passes) / 1000.f;
     }
 }

App/main.cpp

@@ -23,9 +23,15 @@ THE SOFTWARE.
 
 #ifdef __APPLE__
 #include <OpenCL/OpenCL.h>
+<<<<<<< HEAD
+// #define GLFW_INCLUDE_GL3
+// #define GLFW_NO_GLU
+//#include "GLFW/glfw3.h"
+=======
 #define GLFW_INCLUDE_GLCOREARB
 #define GLFW_NO_GLU
 #include "GLFW/glfw3.h"
+>>>>>>> github/baikal-next
 #elif WIN32
 #define NOMINMAX
 #include <Windows.h>
@@ -38,7 +44,6 @@ THE SOFTWARE.
 #include "GLFW/glfw3.h"
 #endif
 
-
 #include "ImGUI/imgui.h"
 #include "ImGUI/imgui_impl_glfw_gl3.h"
 

App/main_benchmark.cpp

@@ -49,13 +49,14 @@ THE SOFTWARE.
 
 #include "math/mathutils.h"
 
-#include "tiny_obj_loader.h"
-#include "perspective_camera.h"
-#include "Scene/scene.h"
-#include "PT/ptrenderer.h"
-#include "AO/aorenderer.h"
+#include "Utils/tiny_obj_loader.h"
+#include "SceneGraph/camera.h"
+#include "SceneGraph/scene1.h"
+#include "Renderers/PT/ptrenderer.h"
+#include "Renderers/AO/aorenderer.h"
 #include "CLW/clwoutput.h"
-#include "config_manager.h"
+#include "Utils/config_manager.h"
+#include "SceneGraph/IO/scene_io.h"
 
 using namespace RadeonRays;
 
@@ -64,7 +65,11 @@ char const* kHelpMessage =
 "App [-p path_to_models][-f model_name][-b][-r][-ns number_of_shadow_rays][-ao ao_radius][-w window_width][-h window_height][-nb number_of_indirect_bounces]";
 char const* g_path =
 "../Resources/bmw";
-char const* g_modelname = "i8.obj";
+//"../Resources/CornellBox";
+
+char const* g_modelname = 
+"i8.obj";
+//"orig.objm";
 
 int g_window_width = 800;
 int g_window_height = 600;
@@ -91,7 +96,7 @@ float g_camera_aperture = 0.f;
 
 
 bool g_recording_enabled = false;
-int g_frame_count = 200;
+int g_pass_count = 200;
 
 ConfigManager::Mode g_mode = ConfigManager::Mode::kUseSingleGpu;
 
@@ -122,7 +127,8 @@ std::vector<std::thread> g_renderthreads;
 int g_primary = -1;
 
 
-std::unique_ptr<Baikal::Scene> g_scene;
+std::unique_ptr<Baikal::Scene1> g_scene;
+std::unique_ptr<Baikal::PerspectiveCamera> g_camera;
 
 // CLW stuff
 CLWImage2D g_cl_interop_image;
@@ -171,30 +177,31 @@ void InitData()
     basepath += "/";
     std::string filename = basepath + g_modelname;
 
-    g_scene.reset(Baikal::Scene::LoadFromObj(filename, basepath));
+    std::unique_ptr<Baikal::SceneIo> scene_io(Baikal::SceneIo::CreateSceneIoObj());
+    g_scene.reset(scene_io->LoadScene(filename, basepath));
 
-    g_scene->camera_.reset(new PerspectiveCamera(
+    g_camera.reset(new Baikal::PerspectiveCamera(
         g_camera_pos
         , g_camera_at
         , g_camera_up));
-
+    g_scene->SetCamera(g_camera.get());
     // Adjust sensor size based on current aspect ratio
     float aspect = (float)g_window_width / g_window_height;
     g_camera_sensor_size.y = g_camera_sensor_size.x / aspect;
 
-    g_scene->camera_->SetSensorSize(g_camera_sensor_size);
-    g_scene->camera_->SetDepthRange(g_camera_zcap);
-    g_scene->camera_->SetFocalLength(g_camera_focal_length);
-    g_scene->camera_->SetFocusDistance(g_camera_focus_distance);
-    g_scene->camera_->SetAperture(g_camera_aperture);
+    g_camera->SetSensorSize(g_camera_sensor_size);
+    g_camera->SetDepthRange(g_camera_zcap);
+    g_camera->SetFocalLength(g_camera_focal_length);
+    g_camera->SetFocusDistance(g_camera_focus_distance);
+    g_camera->SetAperture(g_camera_aperture);
 
-    std::cout << "Camera type: " << (g_scene->camera_->GetAperture() > 0.f ? "Physical" : "Pinhole") << "\n";
-    std::cout << "Lens focal length: " << g_scene->camera_->GetFocalLength() * 1000.f << "mm\n";
-    std::cout << "Lens focus distance: " << g_scene->camera_->GetFocusDistance() << "m\n";
-    std::cout << "F-Stop: " << 1.f / (g_scene->camera_->GetAperture() * 10.f) << "\n";
+    std::cout << "Camera type: " << (g_camera->GetAperture() > 0.f ? "Physical" : "Pinhole") << "\n";
+    std::cout << "Lens focal length: " << g_camera->GetFocalLength() * 1000.f << "mm\n";
+    std::cout << "Lens focus distance: " << g_camera->GetFocusDistance() << "m\n";
+    std::cout << "F-Stop: " << 1.f / (g_camera->GetAperture() * 10.f) << "\n";
     std::cout << "Sensor size: " << g_camera_sensor_size.x * 1000.f << "x" << g_camera_sensor_size.y * 1000.f << "mm\n";
 
-    g_scene->SetEnvironment("../Resources/Textures/studio015.hdr", "", g_envmapmul);
+    //g_scene->SetEnvironment("../Resources/Textures/studio015.hdr", "", g_envmapmul);
 
 #pragma omp parallel for
     for (int i = 0; i < g_cfgs.size(); ++i)
@@ -263,10 +270,8 @@ Baikal::Renderer::BenchmarkStats Update()
     }
 
     {
-        auto const kNumBenchmarkPasses = 100U;
-
         Baikal::Renderer::BenchmarkStats stats;
-        g_cfgs[g_primary].renderer->RunBenchmark(*g_scene.get(), kNumBenchmarkPasses, stats);
+        g_cfgs[g_primary].renderer->RunBenchmark(*g_scene.get(), g_pass_count, stats);
 
         return stats;
     }
@@ -380,8 +385,8 @@ int main(int argc, char * argv[])
     g_cspeed = cspeed ? (atof(cspeed) > 0) : g_cspeed;
 
 
-    char* frame_count = GetCmdOption(argv, argv + argc, "-fc");
-    g_frame_count = frame_count ? (atoi(frame_count)) : g_frame_count;
+    char* pass_count = GetCmdOption(argv, argv + argc, "-fc");
+    g_pass_count = pass_count ? (atoi(pass_count)) : g_pass_count;
 
     char* cfg = GetCmdOption(argv, argv + argc, "-config");
 
@@ -419,24 +424,15 @@ int main(int argc, char * argv[])
         StartRenderThreads();
 
         Baikal::Renderer::BenchmarkStats stats = Update();
-        for (int i = 1; i < g_frame_count; ++i)
-        {
-            Baikal::Renderer::BenchmarkStats iter_stats = Update();
-            stats.primary_rays_time_in_ms += iter_stats.primary_rays_time_in_ms;
-            stats.secondary_rays_time_in_ms += iter_stats.secondary_rays_time_in_ms;
-            stats.shadow_rays_time_in_ms += iter_stats.shadow_rays_time_in_ms;
-        }
-        stats.primary_rays_time_in_ms /= g_frame_count;
-        stats.secondary_rays_time_in_ms /= g_frame_count;
-        stats.shadow_rays_time_in_ms /= g_frame_count;
 
         auto numrays = stats.resolution.x * stats.resolution.y;
         std::cout << "Baikal renderer benchmark\n";
-        std::cout << "Iterations: " << g_frame_count << std::endl;
+        std::cout << "Iterations: " << g_pass_count << std::endl;
         std::cout << "Number of primary rays: " << numrays << std::endl;
         std::cout << "Primary rays: " << (float)(numrays / (stats.primary_rays_time_in_ms * 0.001f) * 0.000001f) << "mrays/s ( " << stats.primary_rays_time_in_ms << "ms )\n";
         std::cout << "Secondary rays: " << (float)(numrays / (stats.secondary_rays_time_in_ms * 0.001f) * 0.000001f) << "mrays/s ( " << stats.secondary_rays_time_in_ms << "ms )\n";
         std::cout << "Shadow rays: " << (float)(numrays / (stats.shadow_rays_time_in_ms * 0.001f) * 0.000001f) << "mrays/s ( " << stats.shadow_rays_time_in_ms << "ms )\n";
+        std::cout << "Samples: " << stats.samples_pes_sec << "msamples/s\n";
     }
     catch (std::runtime_error& err)
     {