Added functions for potential MIS, new function to outsource, directLightning

RayTracer/sampling/Scene.cpp

@@ -34,8 +34,17 @@ util::Vec3 Scene::calculateRadiance(const cam::Ray& r, size_t depth,
 	cam::Ray scatter_ray = h->scattered_ray(r);
 
 	if (h->scatter(scatter_ray.d, h->normal())) {
-		result = h->emission() +
-		         h->albedo() * calculateRadiance(scatter_ray, depth - 1, write);
+		size_t lightSamples = 10;
+		// lightSamples = lightSamples * lightSamples;
+		auto cosine_term = util::dot(h->normal(), scatter_ray.d.normalize());
+		auto brdf = h->material->calculateLightMultiplier(-scatter_ray.d, -r.d,
+		                                                  h->normal());
+		auto brdf_pdf = h->material->brdf_pdf(scatter_ray.d, h->normal());
+		result =
+		    h->emission() +
+		    (h->albedo() * calculateRadiance(scatter_ray, depth - 1, write) *
+		     brdf * cosine_term) /
+		        brdf_pdf;
 
 		// To investigate possible bugs
 		/*
@@ -45,37 +54,68 @@ util::Vec3 Scene::calculateRadiance(const cam::Ray& r, size_t depth,
 		        if (depth == 20) assert(false);
 		    }*/
 #if true
-		for (auto light : lights) {
-			int nn = 1;
-			nn = nn * nn;
-			util::Vec3 lightPart;
-			for (int i = 0; i < nn; i++) {
-				auto samplePoint = light->sampleLight(h.value());
-				auto shadowRay = cam::Ray(
-				    samplePoint.point(), h->point() - samplePoint.point(),
-				    cam::epsilon, 1 - cam::epsilon, false);
-				auto shadowHit = group.intersect(shadowRay);
-				if (!shadowHit) {
+		result = result + directLighting(h, r, lightSamples);
+#endif
+	} else {
+		if (this->depth == depth) result = h->emission();
+		// result = util::Vec3(0);
+		// result = h->emission();
+	}
+	return result;
+	// return h->normal();
+}
+util::Vec3 Scene::directLighting(const std::optional<cam::Hit>& h, cam::Ray r,
+                                 int lightSamples) const {
+	util::Vec3 result;
+	for (auto light : lights) {
+		util::Vec3 lightPart;
+		for (int i = 0; i < lightSamples; i++) {
+			auto samplePoint = light->sampleLight(h.value());
+			auto shadowRay =
+			    cam::Ray(samplePoint.point(), h->point() - samplePoint.point(),
+			             cam::epsilon, 1 - cam::epsilon, false);
+			auto shadowHit = group.intersect(shadowRay);
+			if (!shadowHit) {
+				auto lightPdf = light->lightPdf(samplePoint, shadowRay.d);
+				if (lightPdf > 0) {
 					auto lightEmission =
-					    light->calculateLightEmission(samplePoint, shadowRay.d);
+					    light->lightEmission(samplePoint) / lightPdf;
 					auto lightMultiplier = h->calculateLightMultiplier(
 					    shadowRay.d.normalize(), -r.d, h->normal());
-
 					util::Vec3 scatterFunction =
 					    lightMultiplier * lightEmission *
 					    std::max<float>(
 					        util::dot(-shadowRay.d.normalize(), h->normal()),
 					        0);
 					lightPart = lightPart + (scatterFunction);
+				} else {
+					result = result;
 				}
 			}
-			result = result + (h->albedo() * (lightPart / nn));
 		}
-#endif
-
-	} else {
-		result = h->emission();
+		result = result + (h->albedo() * (lightPart / lightSamples));
 	}
 	return result;
-	// return h->normal();
+}
+float Scene::bsdfMisWeight(const std::optional<cam::Hit>& h,
+                           const cam::Ray& scatterRay,
+                           size_t lights_samples) const {
+	float numerator = h->material->brdf_pdf(scatterRay.d, h->normal());
+	float denominator = numerator;
+	for (auto light : lights) {
+		/*auto light_hit = light->intersect(scatterRay);
+		if (light_hit)
+		    denominator += lights_samples *
+		                   light->lightPdf(light_hit.value(), -scatterRay.d);*/
+	}
+	return numerator / denominator;
+}
+float Scene::lightMisWeight(std::shared_ptr<shapes::Light> light,
+                            const std::optional<cam::Hit>& h,
+                            const util::Vec3& d_in,
+                            const util::SurfacePoint& samplePoint,
+                            size_t light_samples) const {
+	float numerator = light_samples * light->lightPdf(samplePoint, d_in);
+	float denominator = numerator + h->material->brdf_pdf(-d_in, h->normal());
+	return numerator / denominator;
 }

RayTracer/sampling/Scene.h

@@ -3,7 +3,6 @@
 #include <vector>
 
 #include "../camera/CamObs.h"
-#include "../shape/Background.h"
 #include "../shape/Group.h"
 #include "../shape/Light.h"
 #include "Sampler.h"
@@ -18,6 +17,16 @@ class Scene : public util::Sampler {
 	                             bool& write) const;
 
    private:
+	util::Vec3 directLighting(const std::optional<cam::Hit>& h, cam::Ray r,
+	                          int nn) const;
+	float Scene::bsdfMisWeight(const std::optional<cam::Hit>& h,
+	                           const cam::Ray& scatterRay,
+	                           size_t lights_samples) const;
+	float Scene::lightMisWeight(std::shared_ptr<shapes::Light> light,
+	                            const std::optional<cam::Hit>& h,
+	                            const util::Vec3& d_in,
+	                            const util::SurfacePoint& samplePoint,
+	                            size_t light_samples) const;
 	shapes::Group group;
 	std::vector<std::shared_ptr<shapes::Light>> lights;
 	cam::CamObs cam;