Tmp (compiling)

Author: howetuft

include/luxrays/core/namedobject.h

@@ -64,8 +64,17 @@ class NamedObject {
 	std::string name;
 };
 
+
+inline bool operator==(const NamedObject& lhs, const NamedObject& rhs) {
+	return std::addressof(lhs) == std::addressof(rhs);
+}
+
+inline bool operator!=(const NamedObject& lhs, const NamedObject& rhs) {
+	return not (lhs == rhs);
 }
 
+}  // namespace luxrays
+
 BOOST_SERIALIZATION_ASSUME_ABSTRACT(luxrays::NamedObject)
 
 BOOST_CLASS_VERSION(luxrays::NamedObject, 3)

include/luxrays/core/namedobjectvector.h

@@ -53,7 +53,7 @@ inline bool operator==(
 	luxrays::NamedObjectRefWrapper const& lhs,
 	luxrays::NamedObjectRefWrapper const& rhs
 ) {
-	return lhs.get().GetName() == rhs.get().GetName();
+	return std::addressof(lhs.get()) == std::addressof(rhs.get());
 }
 
 struct UndefinedNamedObjectError : public std::runtime_error {

include/luxrays/core/trianglemesh.h

@@ -268,7 +268,7 @@ class InstanceTriangleMesh : virtual public Mesh {
 		cachedArea = -1.f;
 	}
 
-	TriangleMeshRef GetTriangleMesh() const { return *mesh; };
+	TriangleMeshConstRef GetTriangleMesh() const { return *mesh; };
 
 	friend class boost::serialization::access;
 
@@ -356,7 +356,7 @@ class MotionTriangleMesh : virtual public Mesh {
 
 	virtual void ApplyTransform(const Transform &t);
 
-	TriangleMeshRef GetTriangleMesh() const { return *mesh; };
+	TriangleMeshConstRef GetTriangleMesh() const { return *mesh; };
 	const MotionSystem &GetMotionSystem() const { return motionSystem; }
 
 	friend class boost::serialization::access;

include/luxrays/usings.h

@@ -37,37 +37,46 @@ namespace std {
 
 
 
-// OptionalPtr is a template to build an optional reference (meaning a
-// reference that can be null) from a given type.
-// It is especially suitable for reference that are not initialized during
-// construction, but later.
-// Reference, if exists, can be access by operator(), among other methods.
+// OptionalPtr is a template to build an optional pointer from a given type.
+// OptionalPtr differs from a raw pointer in at least two ways:
+// - The absence of a pointed object is represented by std::nullopt. Dereferencing
+// the pointer in this case will raise a std::bad_optional_access exception, rather
+// than the infamous segmentation fault.
+// - By convention, OptionalPtr is explicitely a *non-owning pointer*.
+//
 template<typename T>
 struct OptionalPtr : public std::optional<std::reference_wrapper<T>> {
 	using parent = std::optional<std::reference_wrapper<T>>;
 
 	using parent::operator=;
 	using parent::parent;
 
-	T& operator*() const noexcept {
+	const T& operator*() const {
 		return this->value().get();
 	}
-
-	const T* operator->(void) const {
-		return &this->value().get();
+	T& operator*() {
+		return this->value().get();
 	}
-	T* operator->(void) {
-		return &this->value().get();
+
+	T* operator->(void) const {
+		return std::pointer_traits<T*>::pointer_to(this->value().get());
 	}
 
-	inline bool operator==(const OptionalPtr<T>& rhs) const {
-		if (bool(*this) xor bool(rhs)) return false;
-		if (!*this and !rhs) return true;
-		return &this->value() == &rhs.value();
+	inline bool operator==(const OptionalPtr<T>& other) const {
+		if (bool(*this) xor bool(other)) return false;
+		if (!*this and !other) return true;
+
+		T& lhs = this->value().get();
+		T& rhs = other.value().get();
+
+		return lhs == rhs;  // Rely on underlying type operator
 	}
-	inline bool operator==(const T& rhs) const {
+	inline bool operator==(const T& other) const {
 		if (not this->has_value()) return false;
-		return &this->value().get() == &rhs;
+
+		T& lhs = this->value().get();
+		T& rhs = other;
+		return lhs == rhs;
 	}
 
 

include/slg/imagemap/imagemap.h

@@ -1114,12 +1114,6 @@ struct std::hash<OptionalPtr<const slg::ImageMap>> {
 	}
 };
 
-//bool operator==(slg::ImageMapConstRef im1, slg::ImageMapConstRef im2);
-//bool operator==(const slg::ImageMap im1, const slg::ImageMap im2);
-bool operator==(
-	const OptionalPtr<const slg::ImageMap>, const OptionalPtr<const slg::ImageMap>
-);
-
 
 BOOST_SERIALIZATION_ASSUME_ABSTRACT(slg::ImageMapStorage)
 

include/slg/lights/strategies/distributionlightstrategy.h

@@ -31,7 +31,9 @@ class DistributionLightStrategy : public LightStrategy {
 public:
 	virtual ~DistributionLightStrategy() { delete lightsDistribution; }
 
-	virtual void Preprocess(SceneConstRef scn, const LightStrategyTask taskType) {}
+	virtual void Preprocess(SceneConstRef scn, const LightStrategyTask taskType) {
+		scene = scn;
+	}
 
 	// Used for direct light sampling
 	virtual OptionalPtr<LightSource> SampleLights(

include/slg/lights/strategies/lightstrategy.h

@@ -93,6 +93,9 @@ class LightStrategy {
 
 	LightStrategy(const LightStrategyType t) : type(t) { }
 
+	OptionalPtr<const Scene> scene;  // I think this could be a (mandatory) reference but
+									 // for now, I keep it as a (optional) pointer
+
 private:
 	const LightStrategyType type;
 };

include/slg/textures/texture.h

@@ -121,17 +121,7 @@ inline float Noise(const luxrays::Point &P) {
 	return Noise(P.x, P.y, P.z);
 }
 
-inline bool operator==(TextureConstRef lhs, TextureConstRef rhs) {
-	return &lhs == &rhs;
-}
-
-inline bool operator!=(TextureConstRef lhs, TextureConstRef rhs) {
-	return &lhs != &rhs;
-}
-
-
-
-}
+}  // namespace slg
 
 
 

include/slg/volumes/volume.h

@@ -118,13 +118,7 @@ class SchlickScatter {
 };
 
 
-inline bool operator==(VolumeConstRef v1, VolumeConstRef v2) {
-	return std::addressof(v1) == std::addressof(v2);
-}
-
-
-
-}
+}  // namespace slg
 
 #endif	/* _SLG_VOLUME_H */
 // vim: autoindent noexpandtab tabstop=4 shiftwidth=4

scenes/albedo/luxball-albedo.cfg

@@ -1,3 +1,4 @@
+native.threads.count = 1
 debug.scene.parse.print = 1
 debug.renderconfig.parse.print = 1
 scene.file = scenes/albedo/luxball-albedo.scn