experimental shapes hierarchy and raycasting

[chaz/yoink] / src / Moof / Sphere.hh

diff --git a/src/Moof/Sphere.hh b/src/Moof/Sphere.hh
index 319a3ae24a32b5a36b5d130134fc5bfca5e915aa..f7b6a95fe7a6d89a450291491ad8c1db012fada2 100644 (file)
--- a/src/Moof/Sphere.hh
+++ b/src/Moof/Sphere.hh
@@ -31,7 +31,10 @@
 
 #include <Moof/Cullable.hh>
 #include <Moof/Drawable.hh>
 
 #include <Moof/Cullable.hh>
 #include <Moof/Drawable.hh>

+#include <Moof/Frustum.hh>

 #include <Moof/Math.hh>
 #include <Moof/Math.hh>

+#include <Moof/OpenGL.hh>
+#include <Moof/Shape.hh>

 
 
 namespace Mf {
 
 
 namespace Mf {


@@ -41,41 +44,134 @@ namespace Mf {
  * A round object.
  */
 
  * A round object.
  */
 

-struct Sphere : public Cullable, public Drawable
+template <int D = 3>
+struct Sphere : public Cullable, public Drawable, public Shape<D>

 {
 {

-       Vector3 point;
+       typedef cml::vector< Scalar, cml::fixed<D> >    Vector;
+
+       // (solution - point)^2 - radius^2 = 0
+       Vector  point;

        Scalar  radius;
 
        Sphere() {}
 
        Scalar  radius;
 
        Sphere() {}
 

-       Sphere(const Vector3& p, Scalar r) :
+       Sphere(const Vector& p, Scalar r) :

                point(p),
                radius(r) {}
 
                point(p),
                radius(r) {}
 

-       Sphere(Scalar x, Scalar y, Scalar z, Scalar r) :
-               point(x, y, z),
-               radius(r) {}
+       //Sphere(Scalar x, Scalar y, Scalar z, Scalar r) :
+               //point(x, y, z),
+               //radius(r) {}

 
 

-       void init(const Vector3& p, Scalar r)
+       void init(const Vector& p, Scalar r)

        {
                point = p;
                radius = r;
        }
 
        {
                point = p;
                radius = r;
        }
 

-       void init(const Vector3& p, const Vector3& o)
+       void init(const Vector& p, const Vector& o)

        {
                point = p;
                radius = (o - p).length();
        }
 
        {
                point = p;
                radius = (o - p).length();
        }
 

-       void encloseVertices(const Vector3 vertices[], unsigned count);

 
 

-       void draw(Scalar alpha = 0.0) const;
-       bool isVisible(const Frustum& frustum) const;
+       // a ray inside the sphere will not intersect on its way out
+       Scalar intersectRay(const Ray<D>& ray,
+                       typename Ray<D>::Intersection& intersection)
+       {
+               Vector b = point - ray.point;
+               Scalar z = cml::dot(b, ray.direction);
+
+               // check if the ball is behind the ray
+               if (z < SCALAR(0.0)) return SCALAR(-1.0);
+
+               Scalar d2 = cml::dot(b, b) - z*z;
+               Scalar r2 = radius * radius;
+
+               // check for an intersection
+               if (d2 > r2) return SCALAR(-1.0);
+
+               Scalar t = z - std::sqrt(r2 - d2);
+               ray.solve(intersection.point, t);
+               intersection.normal = intersection.point - point;
+
+               return t;
+       }
+
+
+       //void encloseVertices(const Vector vertices[], unsigned count);
+
+       //void draw(Scalar alpha = 0.0) const;
+       //bool isVisible(const Frustum& frustum) const;
+
+void encloseVertices(const Vector vertices[], unsigned count)
+{
+       // TODO
+}
+
+void draw(Scalar alpha = 0.0) const;
+//{
+       //GLUquadricObj* sphereObj = gluNewQuadric();
+       //gluQuadricDrawStyle(sphereObj, GLU_LINE);
+
+       //glPushMatrix();
+
+       //glTranslate(point);
+       //gluSphere(sphereObj, GLdouble(radius), 16, 16);
+
+       //glPopMatrix();
+
+       //gluDeleteQuadric(sphereObj);
+//}
+
+bool isVisible(const Frustum& frustum) const
+{
+       return true;
+}

 };
 
 
 };
 
 

-inline bool checkCollision(const Sphere& a, const Sphere& b)
+template <>
+inline bool Sphere<3>::isVisible(const Frustum& frustum) const
+{
+       return frustum.contains(*this);
+}
+
+template <>
+inline void Sphere<2>::draw(Scalar alpha) const
+{
+       GLUquadricObj* sphereObj = gluNewQuadric();
+       gluQuadricDrawStyle(sphereObj, GLU_LINE);
+
+       glPushMatrix();
+
+       glTranslate(promote(point));
+       gluSphere(sphereObj, GLdouble(radius), 16, 16);
+
+       glPopMatrix();
+
+       gluDeleteQuadric(sphereObj);
+}
+
+template <>
+inline void Sphere<3>::draw(Scalar alpha) const
+{
+       GLUquadricObj* sphereObj = gluNewQuadric();
+       gluQuadricDrawStyle(sphereObj, GLU_LINE);
+
+       glPushMatrix();
+
+       glTranslate(point);
+       gluSphere(sphereObj, GLdouble(radius), 16, 16);
+
+       glPopMatrix();
+
+       gluDeleteQuadric(sphereObj);
+}
+
+template <int D>
+inline bool checkCollision(const Sphere<D>& a, const Sphere<D>& b)

 {
        Scalar d = (a.point - b.point).length();
        return d < (a.radius + b.radius);
 {
        Scalar d = (a.point - b.point).length();
        return d < (a.radius + b.radius);