Merge pull request #687 from CodeFHD/for_v2.11

CodeFHD · web-flow · commit b6c3edf9d430 · 2025-10-11T19:59:38.000+02:00
Various fixes to BiDir, light tracing, and orthographic camera
diff --git a/include/slg/bsdf/bsdf.h b/include/slg/bsdf/bsdf.h
@@ -128,6 +128,7 @@ class BSDF {
 
 	luxrays::Spectrum GetPassThroughTransparency(const bool backTracing) const;
 	const luxrays::Spectrum &GetPassThroughShadowTransparency() const { return material->GetPassThroughShadowTransparency(); }
+	const bool &GetPassThroughShadowTransparencyOverride() const { return material->GetPassThroughShadowTransparencyOverride(); }
 	const luxrays::Frame &GetFrame() const { return frame; }
 
 	luxrays::Spectrum Albedo() const;
diff --git a/include/slg/cameras/camera.h b/include/slg/cameras/camera.h
@@ -96,6 +96,7 @@ class Camera {
 		float *filmX, float *filmY) const = 0;
 	virtual bool GetSamplePosition(const luxrays::Point &p,
 		float *filmX, float *filmY) const;
+	virtual bool ProjectToImage(luxrays::Ray *ray, float *filmX, float *filmY) const;
 	virtual bool SampleLens(const float time, const float u1, const float u2,
 		luxrays::Point *lensPoint) const = 0;
 	virtual void GetPDF(const luxrays::Ray &eyeRay, const float eyeDistance,
diff --git a/include/slg/cameras/orthographic.h b/include/slg/cameras/orthographic.h
@@ -34,6 +34,7 @@ class OrthographicCamera : public ProjectiveCamera {
 	virtual ~OrthographicCamera() { }
 
 	virtual void ClampRay(luxrays::Ray *ray) const;
+	virtual bool ProjectToImage(luxrays::Ray *ray, float *filmX, float *filmY) const;
 	virtual bool GetSamplePosition(luxrays::Ray *eyeRay, float *filmX, float *filmY) const;
 	virtual bool LocalSampleLens(const float time, const float u1, const float u2,
 		luxrays::Point *lensPoint) const;
diff --git a/include/slg/engines/bidircpu/bidircpu.h b/include/slg/engines/bidircpu/bidircpu.h
@@ -97,7 +97,7 @@ class BiDirCPURenderThread : public CPUNoTileRenderThread {
 		const luxrays::Point &lensPoint, std::vector<SampleResult> &sampleResults) const;
 
 	bool TraceLightPath(const float time,
-		Sampler *sampler, const luxrays::Point &lensPoint,
+		Sampler *sampler, Camera *camera,
 		std::vector<PathVertexVM> &lightPathVertices,
 		std::vector<SampleResult> &sampleResults) const;
 	bool Bounce(const float time, Sampler *sampler, const u_int sampleOffset,
diff --git a/include/slg/engines/pathocl/pathocl.h b/include/slg/engines/pathocl/pathocl.h
@@ -112,10 +112,9 @@ class PathOCLRenderEngine : public PathOCLBaseRenderEngine {
 	void UpdateTaskCount();
 
 	u_int GetTotalEyeSPP() const;
-	
+
 	FilmSampleSplatter *lightSampleSplatter;
 	SamplerSharedData *eyeSamplerSharedData;
-	SamplerSharedData *lightSamplerSharedData;
 
 	bool hasStartFilm, allRenderingThreadsStarted;
 };
diff --git a/include/slg/engines/pathoclbase/pathoclbase.h b/include/slg/engines/pathoclbase/pathoclbase.h
@@ -98,6 +98,8 @@ class PathOCLBaseRenderEngine : public OCLRenderEngine {
 	slg::ocl::Sampler *oclSampler;
 	slg::ocl::Filter *oclPixelFilter;
 	PhotonGICache *photonGICache;
+
+	SamplerSharedData *lightSamplerSharedData;
 };
 
 }
diff --git a/include/slg/materials/material.h b/include/slg/materials/material.h
@@ -123,6 +123,8 @@ class Material : public luxrays::NamedObject {
 
 	void SetPassThroughShadowTransparency(const luxrays::Spectrum &t) { passThroughShadowTransparency = t; }
 	const luxrays::Spectrum &GetPassThroughShadowTransparency() const { return passThroughShadowTransparency; }
+	void SetPassThroughShadowTransparencyOverride(const bool &o) { passThroughShadowTransparencyOverride = o; }
+	const bool &GetPassThroughShadowTransparencyOverride() const { return passThroughShadowTransparencyOverride; }
 
 	virtual luxrays::Spectrum GetEmittedRadiance(const HitPoint &hitPoint,
 		const float oneOverPrimitiveArea) const;
@@ -225,6 +227,7 @@ class Material : public luxrays::NamedObject {
 	const Texture *frontTransparencyTex;
 	const Texture *backTransparencyTex;
 	luxrays::Spectrum passThroughShadowTransparency;
+	bool passThroughShadowTransparencyOverride;
 	const Texture *emittedTex;
 	const Texture *bumpTex;
     float bumpSampleDistance;
diff --git a/include/slg/utils/pathvolumeinfo.h b/include/slg/utils/pathvolumeinfo.h
@@ -50,6 +50,7 @@ class PathVolumeInfo {
 
 	void AddVolume(const Volume *vol);
 	void RemoveVolume(const Volume *vol);
+	void SetCurrentVolume(const Volume *vol) { currentVolume = vol; }
 
 	const Volume *SimulateRemoveVolume(const Volume *vol) const;
 	const Volume *SimulateAddVolume(const Volume *vol) const;
diff --git a/src/slg/cameras/camera.cpp b/src/slg/cameras/camera.cpp
@@ -53,6 +53,11 @@ bool Camera::GetSamplePosition(const luxrays::Point &p,
 	return GetSamplePosition(&eyeRay, filmX, filmY);
 }
 
+bool Camera::ProjectToImage(luxrays::Ray *ray, float *filmX, float *filmY) const{
+	// Intended only for implementation in OrthographicCamera
+	return false;
+}
+
 void Camera::Update(const u_int width, const u_int height, const u_int *subRegion) {
 	filmWidth = width;
 	filmHeight = height;
diff --git a/src/slg/cameras/orthographic.cpp b/src/slg/cameras/orthographic.cpp
@@ -75,6 +75,44 @@ void OrthographicCamera::ClampRay(Ray *ray) const {
 	ray->maxt = Min(ray->maxt, clipYon);
 }
 
+bool OrthographicCamera::ProjectToImage(Ray *ray, float *x, float *y) const {
+	// check if point is behind camera
+	const float cosi = Dot(ray->d, dir);
+
+	if ((cosi <= 0.f) || (!isinf(ray->maxt) && (ray->maxt < clipHither ||
+		ray->maxt > clipYon)))
+		return false;
+
+	// Get coordinates of point in image plane
+	Point pO = Inverse(camTrans.rasterToWorld) * ray->o;
+	if (motionSystem)
+		pO *= motionSystem->Sample(ray->time);
+
+	*x = pO.x;
+	*y = filmHeight - 1 - pO.y;
+
+	// Update the ray origin
+	pO.z = 0.f;
+	ray->o = camTrans.rasterToWorld * pO;
+
+	// Check if we are inside the image plane
+	if ((*x < filmSubRegion[0]) || (*x >= filmSubRegion[1] + 1) ||
+			(*y < filmSubRegion[2]) || (*y >= filmSubRegion[3] + 1))
+		return false;
+	else {
+		// World arbitrary clipping plane support
+		if (enableClippingPlane) {
+			// Check if the ray end point is on the not visible side of the plane
+			if (Dot(clippingPlaneNormal, ray->o - clippingPlaneCenter) <= 0.f)
+				return false;
+			// Update ray mint/maxt
+			ApplyArbitraryClippingPlane(ray);
+		}
+
+		return true;
+	}
+}
+
 bool OrthographicCamera::GetSamplePosition(Ray *ray, float *x, float *y) const {
 	const float cosi = Dot(ray->d, dir);
 
diff --git a/src/slg/engines/bidircpu/bidircputhread.cpp b/src/slg/engines/bidircpu/bidircputhread.cpp
@@ -279,6 +279,9 @@ void BiDirCPURenderThread::ConnectVertices(const float time,
 			BSDF bsdfConn;
 			Spectrum connectionThroughput;
 			PathVolumeInfo volInfo = eyeVertex.volInfo; // I need to use a copy here
+			// For the connection event, we need to evaluate the volume based on whether the shadow ray is going into the object or not
+			bool connectionIntoObject = (Dot(lightVertex.bsdf.hitPoint.geometryN, -shadowRayDir) < 0.f);
+			volInfo.SetCurrentVolume(connectionIntoObject ? lightVertex.bsdf.hitPoint.interiorVolume : lightVertex.bsdf.hitPoint.exteriorVolume);
 			if (!scene->Intersect(device, LIGHT_RAY | INDIRECT_RAY | SHADOW_RAY, &volInfo, u0, &p2pRay, &p2pRayHit, &bsdfConn,
 					&connectionThroughput)) {
 				// Nothing was hit, the light path vertex is visible
@@ -326,24 +329,47 @@ void BiDirCPURenderThread::ConnectToEye(const float time,
 	BiDirCPURenderEngine *engine = (BiDirCPURenderEngine *)renderEngine;
 	Scene *scene = engine->renderConfig->scene;
 
-	Vector eyeDir(lightVertex.bsdf.hitPoint.p - lensPoint);
-	const float eyeDistance = eyeDir.Length();
-	eyeDir /= eyeDistance;
+	Vector eyeDir;
+	float eyeDistance = 0;
+    if (scene->camera->GetType() == Camera::ORTHOGRAPHIC){
+		// Orthographic camera need to be handled separately,
+		// lensPoint can not be pre-calculated in this case
+		Point p = lightVertex.bsdf.hitPoint.p;
+		eyeDir = scene->camera->GetDir();
+		// calculate distance from vertex to camera plane
+		const float D = -eyeDir.x*lensPoint.x - eyeDir.y*lensPoint.y - eyeDir.z*lensPoint.z;
+		eyeDistance = eyeDir.x*p.x + eyeDir.y*p.y + eyeDir.z*p.z + D;
+		eyeDistance = fabsf(eyeDistance);
+	} else {
+		eyeDir = Vector(lightVertex.bsdf.hitPoint.p - lensPoint);
+		eyeDistance = eyeDir.Length();
+		eyeDir /= eyeDistance;
+	}
 
 	float bsdfPdfW, bsdfRevPdfW;
 	BSDFEvent event;
 	const Spectrum bsdfEval = lightVertex.bsdf.Evaluate(-eyeDir, &event, &bsdfPdfW, &bsdfRevPdfW);
 
 	if (!bsdfEval.Black()) {
-		Ray eyeRay(lensPoint, eyeDir,
+		float filmX, filmY;
+		bool sampleSuccess;
+		Ray eyeRay;
+		
+		if (scene->camera->GetType() == Camera::ORTHOGRAPHIC){
+			Vector rayDir(lightVertex.bsdf.hitPoint.p - lensPoint);
+			eyeRay = Ray(lightVertex.bsdf.hitPoint.p, rayDir,
 				0.f,
 				eyeDistance,
 				time);
-		scene->camera->ClampRay(&eyeRay);
-		eyeRay.UpdateMinMaxWithEpsilon();
-
-		float filmX, filmY;
-		if (scene->camera->GetSamplePosition(&eyeRay, &filmX, &filmY)) {
+			sampleSuccess = scene->camera->ProjectToImage(&eyeRay, &filmX, &filmY);
+		} else {
+			eyeRay = Ray(lensPoint, eyeDir,
+				0.f,
+				eyeDistance,
+				time);
+			sampleSuccess = scene->camera->GetSamplePosition(&eyeRay, &filmX, &filmY);
+		}
+		if (sampleSuccess) {
 			// I have to flip the direction of the traced ray because
 			// the information inside PathVolumeInfo are about the path from
 			// the light toward the camera (i.e. ray.o would be in the wrong
@@ -534,7 +560,7 @@ void BiDirCPURenderThread::DirectHitLight(const bool finiteLightSource,
 }
 
 bool BiDirCPURenderThread::TraceLightPath(const float time,
-		Sampler *sampler, const Point &lensPoint,
+		Sampler *sampler, Camera *camera,
 		vector<PathVertexVM> &lightPathVertices,
 		vector<SampleResult> &sampleResults) const {
 	BiDirCPURenderEngine *engine = (BiDirCPURenderEngine *)renderEngine;
@@ -597,7 +623,7 @@ bool BiDirCPURenderThread::TraceLightPath(const float time,
 				// Check if it is something with a not black shadow transparency
 				// and stop if it has. Direct light sampling will take care of
 				// this kind of paths.
-				if (!lightVertex.bsdf.GetPassThroughShadowTransparency().Black())
+				if (!lightVertex.bsdf.GetPassThroughShadowTransparency().Black() & !lightVertex.bsdf.GetPassThroughShadowTransparencyOverride())
 					break;
 
 				// Update the new light vertex
@@ -619,6 +645,10 @@ bool BiDirCPURenderThread::TraceLightPath(const float time,
 					// Try to connect the light path vertex with the eye
 					//----------------------------------------------------------
 
+					// Sample a point on the camera lens
+					Point lensPoint;
+					camera->SampleLens(time, sampler->GetSample(3), sampler->GetSample(4), &lensPoint);
+
 					ConnectToEye(time, lightVertex, sampler->GetSample(sampleOffset + 1),
 							lensPoint, sampleResults);
 				}
@@ -768,6 +798,7 @@ void BiDirCPURenderThread::RenderFunc(std::stop_token stop_token) {
 		const float timeSample = sampler->GetSample(12);
 		const float time = scene->camera->GenerateRayTime(timeSample);
 
+		/*
 		// Sample a point on the camera lens
 		Point lensPoint;
 		if (!camera->SampleLens(time, sampler->GetSample(3), sampler->GetSample(4),
@@ -777,12 +808,13 @@ void BiDirCPURenderThread::RenderFunc(std::stop_token stop_token) {
 			sampler->NextSample(sampleResults);
 			continue;
 		}
+		*/
 
 		//----------------------------------------------------------------------
 		// Trace light path
 		//----------------------------------------------------------------------
 
-		const bool validLightPath = TraceLightPath(time, sampler, lensPoint, lightPathVertices, sampleResults);
+		const bool validLightPath = TraceLightPath(time, sampler, camera, lightPathVertices, sampleResults);
 		assert (SampleResult::IsAllValid(sampleResults));
 
 		if (validLightPath) {
@@ -872,6 +904,7 @@ void BiDirCPURenderThread::RenderFunc(std::stop_token stop_token) {
 					albedoToDo = false;
 				}
 
+				float t_MIS;
 				if (eyeSampleResult.firstPathVertex) {
 					eyeSampleResult.alpha = 1.f;
 					eyeSampleResult.depth = eyeRayHit.t;
@@ -880,11 +913,18 @@ void BiDirCPURenderThread::RenderFunc(std::stop_token stop_token) {
 					eyeSampleResult.materialID = eyeVertex.bsdf.GetMaterialID();
 					eyeSampleResult.objectID = eyeVertex.bsdf.GetObjectID();
 					eyeSampleResult.uv = eyeVertex.bsdf.hitPoint.GetUV(0);
+					// for the camera ray, we need to add the clipping distance
+					// because eyeRayHit.t is measured from clipping start.
+					// Otherwise, the brightness near the front clipping plane may be distorted.
+					t_MIS = eyeRayHit.t + camera->clipHither;
+				} 
+				else{
+					t_MIS = eyeRayHit.t;
 				}
 
 				// Update MIS constants
 				const float factor = 1.f / MIS(AbsDot(eyeVertex.bsdf.hitPoint.shadeN, eyeVertex.bsdf.hitPoint.fixedDir));
-				eyeVertex.dVCM *= MIS(eyeRayHit.t * eyeRayHit.t) * factor;
+				eyeVertex.dVCM *= MIS(t_MIS * t_MIS) * factor;
 				eyeVertex.dVC *= factor;
 				eyeVertex.dVM *= factor;
 
diff --git a/src/slg/engines/bidirvmcpu/bidirvmcputhread.cpp b/src/slg/engines/bidirvmcpu/bidirvmcputhread.cpp
@@ -125,7 +125,7 @@ void BiDirVMCPURenderThread::RenderFuncVM(std::stop_token stop_token) {
 					&lensPoints[samplerIndex]))
 				continue;
 
-			if (!TraceLightPath(time, sampler, lensPoints[samplerIndex],
+			if (!TraceLightPath(time, sampler, camera, //lensPoints[samplerIndex],
 					lightPathsVertices[samplerIndex], samplesResults[samplerIndex]))
 				continue;
 		}
diff --git a/src/slg/engines/pathocl/pathocl.cpp b/src/slg/engines/pathocl/pathocl.cpp
@@ -60,15 +60,13 @@ PathOCLRenderEngine::PathOCLRenderEngine(const RenderConfig *rcfg) :
 		PathOCLBaseRenderEngine(rcfg, true) {
 	lightSampleSplatter = nullptr; 
 	eyeSamplerSharedData = nullptr;
-	lightSamplerSharedData = nullptr;
 	hasStartFilm = false;
 	allRenderingThreadsStarted = false;
 }
 
 PathOCLRenderEngine::~PathOCLRenderEngine() {
 	delete lightSampleSplatter;
 	delete eyeSamplerSharedData;
-	delete lightSamplerSharedData;
 }
 
 PathOCLBaseOCLRenderThread *PathOCLRenderEngine::CreateOCLThread(const u_int index,
@@ -145,8 +143,6 @@ void PathOCLRenderEngine::StartLockLess() {
 	if (nativeRenderThreadCount > 0) {
 		eyeSamplerSharedData = renderConfig->AllocSamplerSharedData(&seedBaseGenerator, film);
 		
-		if (pathTracer.hybridBackForwardEnable)
-			lightSamplerSharedData = MetropolisSamplerSharedData::FromProperties(Properties(), &seedBaseGenerator, film);
 	}
 
 	//--------------------------------------------------------------------------
@@ -174,8 +170,6 @@ void PathOCLRenderEngine::StopLockLess() {
 
 	delete eyeSamplerSharedData;
 	eyeSamplerSharedData = nullptr;
-	delete lightSamplerSharedData;
-	lightSamplerSharedData = nullptr;
 
 	delete photonGICache;
 	photonGICache = nullptr;
diff --git a/src/slg/engines/pathoclbase/pathoclbase.cpp b/src/slg/engines/pathoclbase/pathoclbase.cpp
@@ -54,7 +54,7 @@ using namespace std;
 PathOCLBaseRenderEngine::PathOCLBaseRenderEngine(const RenderConfig *rcfg,
 		const bool supportsNativeThreads) :	OCLRenderEngine(rcfg, supportsNativeThreads),
 		compiledScene(nullptr), pixelFilterDistribution(nullptr), oclSampler(nullptr),
-		oclPixelFilter(nullptr), photonGICache(nullptr) {
+		oclPixelFilter(nullptr), photonGICache(nullptr), lightSamplerSharedData(nullptr) {
 	writeKernelsToFile = false;
 
 	//--------------------------------------------------------------------------
@@ -155,6 +155,7 @@ PathOCLBaseRenderEngine::~PathOCLBaseRenderEngine() {
 	delete[] pixelFilterDistribution;
 	delete oclSampler;
 	delete oclPixelFilter;
+	delete lightSamplerSharedData;
 }
 
 void PathOCLBaseRenderEngine::InitGPUTaskConfiguration() {
@@ -203,6 +204,7 @@ void PathOCLBaseRenderEngine::InitFilm() {
 			Get("path.hybridbackforward.enable")).Get<bool>();
 	if (hybridBackForwardEnable)
 		film->AddChannel(Film::RADIANCE_PER_SCREEN_NORMALIZED);
+		lightSamplerSharedData = MetropolisSamplerSharedData::FromProperties(Properties(), &seedBaseGenerator, film);
 
 	film->SetRadianceGroupCount(renderConfig->scene->lightDefs.GetLightGroupCount());
 	film->Init();
@@ -396,6 +398,8 @@ void PathOCLBaseRenderEngine::StopLockLess() {
 	photonGICache = nullptr;
 	delete[] pixelFilterDistribution;
 	pixelFilterDistribution = nullptr;
+	delete lightSamplerSharedData;
+	lightSamplerSharedData = nullptr;
 }
 
 void PathOCLBaseRenderEngine::BeginSceneEditLockLess() {
@@ -414,6 +418,8 @@ void PathOCLBaseRenderEngine::BeginSceneEditLockLess() {
 }
 
 void PathOCLBaseRenderEngine::EndSceneEditLockLess(const EditActionList &editActions) {
+	if (lightSamplerSharedData)
+		lightSamplerSharedData->Reset();
 	compiledScene->Recompile(editActions);
 
 	for (size_t i = 0; i < renderOCLThreads.size(); ++i) {
diff --git a/src/slg/engines/pathtracer.cpp b/src/slg/engines/pathtracer.cpp
diff --git a/src/slg/scene/parsematerials.cpp b/src/slg/scene/parsematerials.cpp

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,8 @@ class PathOCLBaseRenderEngine : public OCLRenderEngine {`
`98`	`98`	`slg::ocl::Sampler *oclSampler;`
`99`	`99`	`slg::ocl::Filter *oclPixelFilter;`
`100`	`100`	`PhotonGICache *photonGICache;`
	`101`	`+`
	`102`	`+ SamplerSharedData *lightSamplerSharedData;`
`101`	`103`	`};`
`102`	`104`
`103`	`105`	`}`