Point light implementation

Author: yozhijk

App/CL/light.cl

@@ -392,6 +392,63 @@ float DirectionalLight_GetPdf(// Emissive object
     return 0.f;
 }
 
+/*
+ Point light
+ */
+// Get intensity for a given direction
+float3 PointLight_GetLe(// Emissive object
+                              Light const* light,
+                              // Scene
+                              Scene const* scene,
+                              // Geometry
+                              DifferentialGeometry const* dg,
+                              // Direction to light source
+                              float3* wo,
+                              // Textures
+                              TEXTURE_ARG_LIST
+                              )
+{
+    return 0.f;
+}
+
+/// Sample direction to the light
+float3 PointLight_Sample(// Emissive object
+                               Light const* light,
+                               // Scene
+                               Scene const* scene,
+                               // Geometry
+                               DifferentialGeometry const* dg,
+                               // Textures
+                               TEXTURE_ARG_LIST,
+                               // Sample
+                               float2 sample,
+                               // Direction to light source
+                               float3* wo,
+                               // PDF
+                               float* pdf)
+{
+    *wo = light->p - dg->p;
+    *pdf = 1.f;
+    return light->intensity;
+}
+
+/// Get PDF for a given direction
+float PointLight_GetPdf(// Emissive object
+                              Light const* light,
+                              // Scene
+                              Scene const* scene,
+                              // Geometry
+                              DifferentialGeometry const* dg,
+                              // Direction to light source
+                              float3 wo,
+                              // Textures
+                              TEXTURE_ARG_LIST
+                              )
+{
+    return 0.f;
+}
+
+
 
 
 /*
@@ -421,6 +478,8 @@ float3 Light_GetLe(// Light index
             return AreaLight_GetLe(&light, scene, dg, wo, TEXTURE_ARGS);
         case kDirectional:
             return DirectionalLight_GetLe(&light, scene, dg, wo, TEXTURE_ARGS);
+        case kPoint:
+            return PointLight_GetLe(&light, scene, dg, wo, TEXTURE_ARGS);
     }
 
     return make_float3(0.f, 0.f, 0.f);
@@ -452,6 +511,8 @@ float3 Light_Sample(// Light index
             return AreaLight_Sample(&light, scene, dg, TEXTURE_ARGS, sample, wo, pdf);
         case kDirectional:
             return DirectionalLight_Sample(&light, scene, dg, TEXTURE_ARGS, sample, wo, pdf);
+        case kPoint:
+            return PointLight_Sample(&light, scene, dg, TEXTURE_ARGS, sample, wo, pdf);
     }
 
     *pdf = 0.f;
@@ -481,6 +542,8 @@ float Light_GetPdf(// Light index
             return AreaLight_GetPdf(&light, scene, dg, wo, TEXTURE_ARGS);
         case kDirectional:
             return DirectionalLight_GetPdf(&light, scene, dg, wo, TEXTURE_ARGS);
+        case kPoint:
+            return PointLight_GetPdf(&light, scene, dg, wo, TEXTURE_ARGS);
     }
 
     return 0.f;

App/Core/output.h

@@ -1,3 +1,32 @@
+/**********************************************************************
+ Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved.
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ********************************************************************/
+
+/**
+ \file output.h
+ \author Dmitry Kozlov
+ \version 1.0
+ \brief Contains declaration of Baikal::Output class, core interface representing renderer output surface.
+ */
+
 #pragma once
 
 #include "math/float3.h"
@@ -6,9 +35,21 @@
 
 namespace Baikal
 {
+    
+    /**
+     \brief Interface for rendering output. 
+     
+     Represents discrete 2D surface with [0..w]x[0..h] coordinate ranges.
+     */
     class Output
     {
     public:
+        /**
+         \brief Create output of a given size
+         
+         \param w Output surface width
+         \param h Output surface height
+         */
         Output(std::uint32_t w, std::uint32_t h)
         : m_width(w)
         , m_height(h)
@@ -17,13 +58,25 @@ namespace Baikal
 
         virtual ~Output() = default;
 
+        /**
+         \brief Interface for rendering output.
+         
+         Represents discrete 2D surface with [0..w]x[0..h] coordinate ranges.
+         */
         virtual void GetData(RadeonRays::float3* data) const = 0;
 
-        std::uint32_t width() const { return m_width; }
-        std::uint32_t height() const { return m_height; }
+        // Get surface width
+        std::uint32_t width() const;
+        // Get surface height
+        std::uint32_t height() const;
 
     private:
+        // Surface width
         std::uint32_t m_width;
+        // Surface height
         std::uint32_t m_height;
     };
+    
+    inline std::uint32_t Output::width() const { return m_width; }
+    inline std::uint32_t Output::height() const { return m_height; }
 }

App/Core/renderer.h

@@ -19,6 +19,13 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ********************************************************************/
+
+/**
+ \file renderer.h
+ \author Dmitry Kozlov
+ \version 1.0
+ \brief Contains declaration of Baikal::Renderer class, core interface representing representing the renderer.
+ */
 #pragma once
 
 #include "math/float3.h"
@@ -30,43 +37,80 @@ namespace Baikal
     class Output;
     class Scene;
 
-    ///< Renderer interface
+    /**
+     \brief Interface for the renderer.
+     
+     Renderer implemenation is taking the scene and producing its image into an output surface.
+     */
     class Renderer
     {
     public:
         Renderer() = default;
-        // Destructor
         virtual ~Renderer() = default;
-        // Create output
+        
+        /**
+         \brief Create output of a given size.
+         
+         \param w Output surface width
+         \param h Output surface height
+         */
         virtual Output* CreateOutput(std::uint32_t w, std::uint32_t h) const = 0;
-        // Delete output
+        
+        /**
+         \brief Delete given output.
+         
+         \param output The output to delete
+         */
         virtual void DeleteOutput(Output* output) const = 0;
-        // Clear output
+        
+        /**
+         \brief Clear output surface using given value.
+         
+         \param val Value to clear to
+         \param output Output to clear
+         */
         virtual void Clear(RadeonRays::float3 const& val, Output& output) const = 0;
-        // Do necessary precalculation and initialization
-        // TODO: is it really necessary? can be async? progress reporting?
+        
+        /**
+         \brief Do necessary scene dependent computations and caching.
+         
+         \param scene The scene to process
+         */
         virtual void Preprocess(Scene const& scene) = 0;
-        // Render single iteration
+        
+        /**
+         \brief Render single iteration.
+         
+         \param scene Scene to render
+         */
         virtual void Render(Scene const& scene) = 0;
-        // Set output
+        
+        /**
+         \brief Set the output for rendering.
+         
+         \param output The output to render into.
+         */
         virtual void SetOutput(Output* output) = 0;
 
-
+        
+        /**
+            Forbidden stuff.
+         */
+        Renderer(Renderer const&) = delete;
+        Renderer& operator = (Renderer const&) = delete;
+        
+        
+        // Temporary functionality
         struct BenchmarkStats
         {
             std::uint32_t num_passes;
-
+            
             RadeonRays::int2 resolution;
             float primary_rays_time_in_ms;
             float secondary_rays_time_in_ms;
             float shadow_rays_time_in_ms;
         };
-
-        // Run render benchmark
+        
         virtual void RunBenchmark(Scene const& scene, std::uint32_t num_passes, BenchmarkStats& stats) {}
-
-        // Does not make sense to copy it
-        Renderer(Renderer const&) = delete;
-        Renderer& operator = (Renderer const&) = delete;
     };
 }

App/PT/ptrenderer.cpp

@@ -272,13 +272,13 @@ namespace Baikal
         m_render_data->intersections = m_context.CreateBuffer<Intersection>(output.width() * output.height(), CL_MEM_READ_WRITE);
         m_vidmemws += output.width() * output.height() * sizeof(Intersection);
 
-        m_render_data->shadowrays = m_context.CreateBuffer<ray>(2 * output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
+        m_render_data->shadowrays = m_context.CreateBuffer<ray>(output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
         m_vidmemws += output.width() * output.height() * sizeof(ray)* kMaxLightSamples;
 
-        m_render_data->shadowhits = m_context.CreateBuffer<int>(2 * output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
+        m_render_data->shadowhits = m_context.CreateBuffer<int>(output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
         m_vidmemws += output.width() * output.height() * sizeof(int)* kMaxLightSamples;
 
-        m_render_data->lightsamples = m_context.CreateBuffer<float3>(2 * output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
+        m_render_data->lightsamples = m_context.CreateBuffer<float3>(output.width() * output.height() * kMaxLightSamples, CL_MEM_READ_WRITE);
         m_vidmemws += output.width() * output.height() * sizeof(float3)* kMaxLightSamples;
 
         m_render_data->paths = m_context.CreateBuffer<PathState>(output.width() * output.height(), CL_MEM_READ_WRITE);

App/Scene/scene.cpp

@@ -1265,7 +1265,16 @@ void Scene::AddDirectionalLight(RadeonRays::float3 const& d, RadeonRays::float3
     light.intensity = e;
     lights_.push_back(light);
 }
-
+    
+void Scene::AddPointLight(RadeonRays::float3 const& p, RadeonRays::float3 const& e)
+{
+    Light light;
+    light.type = kPoint;
+    light.p = p;
+    light.intensity = e;
+    lights_.push_back(light);
+}
+    
 void Scene::SetEnvironment(std::string const& filename, std::string const& basepath, float envmapmul)
 {
     // Save multiplier

App/Scene/scene.h

@@ -44,6 +44,8 @@ namespace Baikal
         void SetBackground(std::string const& filename, std::string const& basepath = "");
 
         void AddDirectionalLight(RadeonRays::float3 const& d, RadeonRays::float3 const& e);
+        
+        void AddPointLight(RadeonRays::float3 const& p, RadeonRays::float3 const& e);
 
         enum DirtyFlags
         {

App/main.cpp

@@ -87,14 +87,14 @@ GLuint g_vertex_buffer;
 GLuint g_index_buffer;
 GLuint g_texture;
 
-int g_window_width = 800;
-int g_window_height = 600;
+int g_window_width = 512;
+int g_window_height = 512;
 int g_num_shadow_rays = 1;
 int g_num_ao_rays = 1;
 int g_ao_enabled = false;
 int g_progressive = false;
 int g_num_bounces = 5;
-int g_num_samples = -1;
+int g_num_samples = 256;
 int g_samplecount = 0;
 float g_ao_radius = 1.f;
 float g_envmapmul = 1.f;
@@ -365,6 +365,7 @@ void InitData()
 
     //g_scene->SetEnvironment(g_envmapname, "", g_envmapmul);
     g_scene->AddDirectionalLight(RadeonRays::float3(-0.3f, -1.f, -0.4f), RadeonRays::float3(1.f, 1.f, 1.f));
+    g_scene->AddPointLight(RadeonRays::float3(0.5f, 1.5f, 0.0f), RadeonRays::float3(1.f, 0.6f, 1.f));
 
 #pragma omp parallel for
     for (int i = 0; i < g_cfgs.size(); ++i)

CLW/CLWProgram.cpp

@@ -70,17 +70,7 @@ CLWProgram CLWProgram::CreateFromSource(char const* sourcecode, size_t sourcesiz
         deviceIds[i] = context.GetDevice(i);
     }
 
-    char const* buildopts1 = 
-#if defined(__APPLE__)
-        "-D APPLE -cl-mad-enable -cl-fast-relaxed-math -cl-std=CL1.2 -I ."
-#elif defined(_WIN32) || defined (WIN32)
-        "-D WIN32 -cl-mad-enable -cl-std=CL1.2 -I."
-#elif defined(__linux__)
-        "-D __linux__ -I."
-#else
-        nullptr
-#endif
-        ;
+
 
     status = clBuildProgram(program, context.GetDeviceCount(), &deviceIds[0], buildopts, nullptr, nullptr);
 
@@ -267,4 +257,4 @@ CLWKernel CLWProgram::GetKernel(std::string const& funcName) const
     ThrowIf(iter == kernels_.end(), CL_INVALID_KERNEL_NAME, "No such kernel in program");
 
     return iter->second;
-}
+}