adding planes

Author: prince-chrismc

Assignments/Ray-Tracing/Ray Tracing.vcxproj

@@ -169,6 +169,7 @@
     <ClCompile Include="src\BuilderUtility.cpp" />
     <ClCompile Include="src\Camera.cpp" />
     <ClCompile Include="src\Model.cpp" />
+    <ClCompile Include="src\Plane.cpp" />
     <ClCompile Include="src\Sphere.cpp" />
     <ClCompile Include="src\Light.cpp" />
     <ClCompile Include="src\RayTracing.cpp" />
@@ -180,6 +181,7 @@
     <ClInclude Include="src\BuilderUtility.h" />
     <ClInclude Include="src\Camera.h" />
     <ClInclude Include="src\Model.h" />
+    <ClInclude Include="src\Plane.h" />
     <ClInclude Include="src\Sphere.h" />
     <ClInclude Include="src\Light.h" />
     <ClInclude Include="src\Scene.h" />

Assignments/Ray-Tracing/Ray Tracing.vcxproj.filters

@@ -51,6 +51,9 @@
     <ClCompile Include="src\BuilderUtility.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\Plane.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\SceneFile.h">
@@ -77,5 +80,8 @@
     <ClInclude Include="src\BuilderUtility.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\Plane.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Assignments/Ray-Tracing/render2_000001.bmp

@@ -0,0 +1,79 @@
+/*
+MIT License
+
+Copyright (c) 2017 Chris McArthur, prince.chrismc(at)gmail(dot)com
+
+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.
+*/
+
+#include "Plane.h"
+#include "glm\geometric.hpp"
+
+bool Plane::TestIntersection(const glm::vec3& cam_pos, const glm::vec3& ray_dir, glm::vec3* out_intersection, float* out_distance) const
+{
+   auto normal = glm::normalize(m_Normal);
+   float denom = glm::dot(normal, ray_dir);
+
+   if (abs(denom) > 1e-6)
+   {
+      glm::vec3 p0l0 = m_Pos - ray_dir;
+
+      *out_distance = glm::dot(p0l0, normal) / denom;
+      *out_intersection = cam_pos + ray_dir * (*out_distance);
+
+      return (*out_distance >= 0);
+   }
+
+   return false;
+}
+
+Plane::Builder& Plane::Builder::ParsePlane(const std::string& data)
+{
+   std::string cut = data.substr(2, data.length() - 4);
+
+   for (std::string attribute : ParseParams(cut))
+   {
+      if (attribute.find("pos:") == 0)
+      {
+         m_Pos = ParseVec3(attribute.substr(5));
+      }
+      else if (attribute.find("nor:") == 0)
+      {
+         m_Normal = ParseVec3(attribute.substr(5));
+      }
+      else if (attribute.find("amb:") == 0)
+      {
+         m_Amb = ParseVec3(attribute.substr(5));
+      }
+      else if (attribute.find("dif:") == 0)
+      {
+         m_Dif = ParseVec3(attribute.substr(5));
+      }
+      else if (attribute.find("spe:") == 0)
+      {
+         m_Spe = ParseVec3(attribute.substr(5));
+      }
+      else if (attribute.find("shi:") == 0)
+      {
+         m_Shine = ParseDouble(attribute.substr(5));
+      }
+   }
+
+   return *this;
+}

Assignments/Ray-Tracing/src/Plane.cpp

@@ -0,0 +1,73 @@
+/*
+MIT License
+
+Copyright (c) 2017 Chris McArthur, prince.chrismc(at)gmail(dot)com
+
+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.
+*/
+
+#pragma once
+
+#include "BuilderUtility.h"
+#include "glm\vec3.hpp"
+#include <string>
+
+class Plane
+{
+   public:
+      Plane() = default;
+      Plane(const glm::vec3& pos, const glm::vec3& nor, const glm::vec3& amb, const glm::vec3& dif, const glm::vec3& spe, const double& shine) :
+         m_Pos(pos), m_Normal(nor),  m_Amb(amb), m_Dif(dif), m_Spe(spe), m_Shine(shine) {}
+
+      bool TestIntersection(const glm::vec3& cam_pos, const glm::vec3& ray_dir, glm::vec3* out_intersection, float* out_distance) const;
+
+      glm::vec3 GetPosition() const { return m_Pos; }
+      glm::vec3 GetNormal() const { return m_Normal; }
+      glm::vec3 GetAmbientlight() const { return m_Amb; }
+      glm::vec3 GetDiffusion() const { return m_Dif; }
+      glm::vec3 GetSpecular() const { return m_Spe; }
+      double GetShine() const { return m_Shine; }
+
+      class Builder : private BuilderUtility
+      {
+      public:
+         Builder() = default;
+         Builder(const Builder&) = delete;
+         void operator=(const Builder&) = delete;
+
+         Builder& ParsePlane(const std::string& data);
+         Plane GetPlane() { return Plane(m_Pos, m_Normal, m_Amb, m_Dif, m_Spe, m_Shine); }
+
+      private:
+         glm::vec3 m_Pos;
+         glm::vec3 m_Normal;
+         glm::vec3 m_Amb;
+         glm::vec3 m_Dif;
+         glm::vec3 m_Spe;
+         double m_Shine;
+      };
+
+private:
+   glm::vec3 m_Pos;
+   glm::vec3 m_Normal;
+   glm::vec3 m_Amb;
+   glm::vec3 m_Dif;
+   glm::vec3 m_Spe;
+   double m_Shine;
+};

Assignments/Ray-Tracing/src/Plane.h

@@ -66,6 +66,14 @@ Scene::Scene(const char* path) : SceneFile(path)
          }
       }
 
+      {
+         std::string plane_attr = "";
+         while ((plane_attr = GetAttributes("plane")) != "")
+         {
+            m_Planes.push_back(Plane::Builder().ParsePlane(plane_attr).GetPlane());
+         }
+      }
+
       GenerateScene();
    }
 }
@@ -130,7 +138,6 @@ void Scene::GenerateScene()
                      glm::vec3 lightAddition = light.GetColor() * (target.m_Sphere.GetDiffusion()*ln + (target.m_Sphere.GetSpecular()*rv));
                      pixelColor += lightAddition;
                   }
-
                   break;
                case IntersectingObject::TRIANGLE:
                   if (IsLightObstructed(&light, &target))
@@ -150,14 +157,36 @@ void Scene::GenerateScene()
                      float rv = glm::dot(reflection, v);
                      if (ln < 0) { ln = 0; }
                      if (rv < 0) { rv = 0; }
-                     rv = pow(rv, target.m_Triangle.GetShine());
+                     rv = std::pow(rv, target.m_Triangle.GetShine());
 
                      pixelColor += target.m_Triangle.GetAmbientlight();
                      glm::vec3 lightAddition = light.GetColor()*(target.m_Triangle.GetDiffusion()*ln + target.m_Triangle.GetSpecular()*rv);
                      pixelColor += lightAddition;
                   }
                   break;
+               case IntersectingObject::PLANE:
+                  if (IsLightObstructed(&light, &target))
+                  {
+                     pixelColor += target.m_Plane.GetAmbientlight();
+                  }
+                  else
+                  {
+                     glm::vec3 normal = glm::normalize(target.m_Plane.GetNormal());
+                     glm::vec3 v = -rayDirection;
+                     glm::vec3 light_direction = glm::normalize(target.m_Point - light.GetPosition());
+                     glm::vec3 reflection = glm::reflect(light_direction, normal);
+                     float ln = glm::dot(normal, light_direction);
+                     float rv = glm::dot(reflection, v);
+                     if (ln < 0) { ln = 0; }
+                     if (rv < 0) { rv = 0; }
 
+                     rv = std::pow(rv, target.m_Plane.GetShine());
+                     pixelColor += target.m_Plane.GetAmbientlight();
+                     glm::vec3 lightAddition = light.GetColor()*(target.m_Plane.GetDiffusion()*ln + target.m_Plane.GetSpecular()*rv);
+                     pixelColor += lightAddition;
+
+                  }
+                  break;
                default:
                   break;
                }
@@ -206,6 +235,20 @@ Scene::IntersectingObject Scene::FindNearestIntersectingObject(glm::vec3 ray_dir
       }
    }
 
+   for (Plane plane : m_Planes)
+   {
+      float distance;
+      glm::vec3 intersectpoint;
+
+      if (plane.TestIntersection(m_Camera.GetPosition(), ray_dir, &intersectpoint, &distance))
+      {
+         if (target.m_ObjType == IntersectingObject::INVALID || distance < target.m_Distance)
+         {
+            target = IntersectingObject(intersectpoint, distance, plane);
+         }
+      }
+   }
+
    return target;
 }
 
@@ -227,5 +270,10 @@ bool Scene::IsLightObstructed(Light* light, IntersectingObject* target)
       if (triangle.TestIntersection(lightRayWithBias, lightRay, &intersectpoint, &distance)) return true;
    }
 
+   for (Plane plane : m_Planes)
+   {
+      if(plane.TestIntersection(lightRayWithBias, lightRay, &intersectpoint, &distance)) return true;
+   }
+
    return false;
 }

Assignments/Ray-Tracing/src/Scene.cpp

@@ -29,7 +29,7 @@ SOFTWARE.
 #include "Light.h"
 #include "Sphere.h"
 #include "Triangle.h"
-#include "Model.h"
+#include "Plane.h"
 
 #include "CImg.h"
 
@@ -44,23 +44,25 @@ class Scene : private SceneFile
       Camera m_Camera;
       std::vector<Light> m_Lights;
       std::vector<Sphere> m_Spheres;
-      std::vector<Model> m_Models;
+      std::vector<Plane> m_Planes;
       std::vector<Triangle> m_Triangles;
 
       cimg_library::CImg<float> m_Img;
 
       struct IntersectingObject
       {
-         enum ObjectType { INVALID, SPHERE, TRIANGLE };
+         enum ObjectType { INVALID, SPHERE, TRIANGLE, PLANE };
 
-         IntersectingObject(glm::vec3 point, float dis, Sphere& sphere) : m_Point(point), m_Distance(dis), m_Sphere(sphere), m_Triangle(), m_ObjType(IntersectingObject::SPHERE) {}
-         IntersectingObject(glm::vec3 point, float dis, Triangle& triangle) : m_Point(point), m_Distance(dis), m_Sphere(), m_Triangle(triangle), m_ObjType(IntersectingObject::TRIANGLE) {}
-         IntersectingObject() : m_Point(0.0f), m_Distance(0.0f), m_Sphere(), m_Triangle(), m_ObjType(IntersectingObject::INVALID) {}
+         IntersectingObject(glm::vec3 point, float dis, Sphere& sphere)     : m_Point(point), m_Distance(dis), m_Sphere(sphere),     m_ObjType(IntersectingObject::SPHERE) {}
+         IntersectingObject(glm::vec3 point, float dis, Triangle& triangle) : m_Point(point), m_Distance(dis), m_Triangle(triangle), m_ObjType(IntersectingObject::TRIANGLE) {}
+         IntersectingObject(glm::vec3 point, float dis, Plane& plane)       : m_Point(point), m_Distance(dis), m_Plane(plane),       m_ObjType(IntersectingObject::PLANE) {}
+         IntersectingObject() : m_Point(0.0f), m_Distance(0.0f), m_Sphere(), m_Triangle(), m_Plane(), m_ObjType(IntersectingObject::INVALID) {}
 
          glm::vec3 m_Point;
          float m_Distance;
          Sphere m_Sphere;
          Triangle m_Triangle;
+         Plane m_Plane;
          ObjectType m_ObjType;
       };