work on raytracing

geo/Sphere3.h

@@ -0,0 +1,128 @@
+#ifndef SPHERE3_H
+#define SPHERE3_H
+
+#include "Point3.h"
+#include "Ray3.h"
+
+#include <vector>
+
+
+struct Sphere3 {
+
+	Point3 center;
+
+	float radius;
+
+	/** empty ctor */
+	Sphere3() : center(), radius(0) {;}
+
+	/** ctor */
+	Sphere3(const Point3 center, const float radius) : center(center), radius(radius) {;}
+
+	/** create a sphere that fully contains the given point-set */
+	static Sphere3 around(const std::vector<Point3>& lst) {
+
+		// NOT OPTIMAL but fast
+		Point3 sum(0,0,0);
+		for (const Point3 p : lst) {sum += p;}
+		const Point3 center = sum / lst.size();
+		float radius = 0;
+		for (const Point3 p : lst) {
+			const float dist = center.getDistance(p);
+			if (dist > radius) {radius = dist;}
+		}
+		return Sphere3(center, radius);
+
+	}
+
+
+
+
+	static Sphere3 join(const Sphere3& a, const Sphere3& b) {
+
+		if (a.contains(b)) {return a;}
+		if (b.contains(a)) {return b;}
+
+		Point3 newCen = (a.center + b.center) / 2;
+		float newRad = (a.center.getDistance(b.center) + std::max(a.radius, b.radius) * 2) / 2;
+		return Sphere3(newCen, newRad);
+	}
+
+	/** does this sphere contain the given sphere? */
+	bool contains(const Sphere3& o) const {
+		return (o.center.getDistance(this->center) + o.radius) < this->radius;
+	}
+
+	/** does the sphere contain the given point? */
+	bool contains(const Point3& p) const {
+		return center.getDistance(p) <= radius;
+	}
+
+	bool intersects(const Ray3& ray) const {
+
+		if (contains(ray.start)) {return true;}
+
+		/*
+		// https://stackoverflow.com/questions/6533856/ray-sphere-intersection
+
+		const float xA = ray.start.x;
+		const float yA = ray.start.y;
+		const float zA = ray.start.z;
+
+		const float xB = (ray.start + ray.dir).x;
+		const float yB = (ray.start + ray.dir).y;
+		const float zB = (ray.start + ray.dir).z;
+
+		const float xC = center.x;
+		const float yC = center.y;
+		const float zC = center.z;
+
+		const float a = (xB-xA)*(xB-xA)+(yB-yA)*(yB-yA)+(zB-zA)*(zB-zA);
+		const float b = 2*((xB-xA)*(xA-xC)+(yB-yA)*(yA-yC)+(zB-zA)*(zA-zC));
+		const float c = (xA-xC)*(xA-xC)+(yA-yC)*(yA-yC)+(zA-zC)*(zA-zC)-(radius*radius);
+
+		const float delta = (b*b) - (4*a*c);
+
+		// intersection?
+		return delta >= 0;
+		*/
+
+
+		// http://www.ccs.neu.edu/home/fell/CSU540/programs/RayTracingFormulas.htm
+
+		const double x0 = ray.start.x;
+		const double y0 = ray.start.y;
+		const double z0 = ray.start.z;
+
+		const double cx = center.x;
+		const double cy = center.y;
+		const double cz = center.z;
+
+		const double dx = ray.dir.x;
+		const double dy = ray.dir.y;
+		const double dz = ray.dir.z;
+
+		const double a = dx*dx + dy*dy + dz*dz;
+		const double b = 2*dx*(x0-cx) +  2*dy*(y0-cy) +  2*dz*(z0-cz);
+		const double c = cx*cx + cy*cy + cz*cz + x0*x0 + y0*y0 + z0*z0 + -2*(cx*x0 + cy*y0 + cz*z0) - radius*radius;
+
+		const double discriminant = (b*b) - (4*a*c);
+		return discriminant >= 0;
+
+
+		/*
+		// http://www.pixelnerve.com/v/2009/02/08/ray-sphere-intersection/
+		const float a = ray.dir.length();
+		//if (a == 0.0)  return 0;
+		const float b = 2.0f * ( dot(ray.start, ray.dir) - dot(ray.dir, center)) ;
+		const Point3 tempDiff = center - ray.start;
+		const float c = tempDiff.length() - (radius*radius);
+		const float disc = b * b - 4 * a * c;
+		return disc >= 0.0f;
+		*/
+
+	}
+
+};
+
+#endif // SPHERE3_H