Added geometry primitives

src/basics/CappedCylinder.cpp

@@ -0,0 +1,79 @@
+#include "CappedCylinder.h"
+
+#include "Vector3.h"
+#include "PackStream.h"
+
+CappedCylinder::CappedCylinder()
+{
+}
+
+CappedCylinder::CappedCylinder(const Vector3 &base, const Vector3 &direction, double radius, double length):
+    InfiniteCylinder(InfiniteRay(base, direction), radius), length(length)
+{
+}
+
+int CappedCylinder::checkRayIntersection(const InfiniteRay &ray, Vector3 *first_intersection, Vector3 *second_intersection) const
+{
+    // TODO Apply the caps
+    int count = InfiniteCylinder::checkRayIntersection(ray, first_intersection, second_intersection);
+
+    if (count == 0)
+    {
+        return 0;
+    }
+    else if (count == 2)
+    {
+        if (checkPointProjection(first_intersection))
+        {
+            if (checkPointProjection(second_intersection))
+            {
+                return 2;
+            }
+            else
+            {
+                return 1;
+            }
+        }
+        else
+        {
+            if (checkPointProjection(second_intersection))
+            {
+                *first_intersection = *second_intersection;
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+    }
+    else  // count == 1
+    {
+        if (checkPointProjection(first_intersection))
+        {
+            return 1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+}
+
+bool CappedCylinder::checkPointProjection(Vector3 *point) const
+{
+    double proj_length = axis.getDirection().dotProduct(point->sub(axis.getOrigin()));
+    return 0.0 <= proj_length && proj_length <= length;
+}
+
+void CappedCylinder::save(PackStream *stream) const
+{
+    InfiniteCylinder::save(stream);
+    stream->write(&length);
+}
+
+void CappedCylinder::load(PackStream *stream)
+{
+    InfiniteCylinder::load(stream);
+    stream->read(&length);
+}

src/basics/CappedCylinder.h

@@ -0,0 +1,42 @@
+#ifndef CAPPEDCYLINDER_H
+#define CAPPEDCYLINDER_H
+
+#include "basics_global.h"
+
+#include "InfiniteCylinder.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Geometric cylinder, with capped ends (not infinite).
+ */
+class BASICSSHARED_EXPORT CappedCylinder: public InfiniteCylinder
+{
+public:
+    CappedCylinder();
+    CappedCylinder(const Vector3 &base, const Vector3 &direction, double radius, double length);
+
+    inline double getLength() const {return length;}
+
+    /**
+     * Check the intersection between the cylinder and an infinite ray.
+     */
+    int checkRayIntersection(const InfiniteRay &ray, Vector3 *first_intersection, Vector3 *second_intersection) const;
+
+    /**
+     * Check if a point projects in the length of the finite cylinder.
+     */
+    bool checkPointProjection(Vector3 *point) const;
+
+    virtual void save(PackStream *stream) const override;
+    virtual void load(PackStream *stream) override;
+
+private:
+    double length;
+};
+
+}
+}
+
+#endif // CAPPEDCYLINDER_H

src/basics/Disk.cpp

@@ -0,0 +1,43 @@
+#include "Disk.h"
+
+#include "PackStream.h"
+
+Disk::Disk()
+{
+}
+
+Disk::Disk(const Vector3 &point, const Vector3 &normal, double radius):
+    InfinitePlane(point, normal), radius(radius)
+{
+    radius2 = radius * radius;
+}
+
+int Disk::checkRayIntersection(const InfiniteRay &ray, Vector3 *intersection) const
+{
+    int result = InfinitePlane::checkRayIntersection(ray, intersection);
+
+    if (result == 1)
+    {
+        Vector3 v = intersection->sub(getPoint());
+        double d2 = v.dotProduct(v);
+        return (d2 <= radius2) ? 1 : 0;
+    }
+    else
+    {
+        return result;
+    }
+}
+
+void Disk::save(PackStream *stream) const
+{
+    InfinitePlane::save(stream);
+    stream->write(&radius);
+    stream->write(&radius2);
+}
+
+void Disk::load(PackStream *stream)
+{
+    InfinitePlane::load(stream);
+    stream->read(&radius);
+    stream->read(&radius2);
+}

src/basics/Disk.h

@@ -0,0 +1,42 @@
+#ifndef DISK_H
+#define DISK_H
+
+#include "basics_global.h"
+
+#include "InfinitePlane.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Geometric plane disk.
+ */
+class BASICSSHARED_EXPORT Disk: public InfinitePlane
+{
+public:
+    Disk();
+    Disk(const Vector3 &point, const Vector3 &normal, double radius);
+
+    inline double getRadius() const {return radius;}
+
+    /**
+     * Check the intersection between the disk and an infinite ray.
+     *
+     * Returns the number of intersections (0, 1), and fill the intersection point.
+     *
+     * Returns -1 if the ray shares a segment with the disk.
+     */
+    int checkRayIntersection(const InfiniteRay& ray, Vector3 *intersection) const;
+
+    void save(PackStream *stream) const override;
+    void load(PackStream *stream) override;
+
+private:
+    double radius;
+    double radius2;
+};
+
+}
+}
+
+#endif // DISK_H

src/basics/InfiniteCylinder.cpp

@@ -0,0 +1,149 @@
+#include "InfiniteCylinder.h"
+
+#include "PackStream.h"
+
+#define EPS 1E-8
+
+InfiniteCylinder::InfiniteCylinder()
+{
+}
+
+InfiniteCylinder::InfiniteCylinder(const InfiniteRay &axis, double radius):
+    axis(axis), radius(radius)
+{
+}
+
+int InfiniteCylinder::checkRayIntersection(const InfiniteRay &ray, Vector3 *first_intersection, Vector3 *second_intersection) const
+{
+    /*
+     * Original algorithm has been altered, because it didn't work with non-(0,0,0) axis origin.
+     * Maybe some optimizations could be made from this.
+     */
+
+    Vector3 U, V, F = axis.getDirection(), P, B, Q, G, AG, AQ;
+    double length, invLength, prod;
+    double R[3][3], A[3][3];
+    double e0, e1, C, c0, c1, c2, discr, invC2, root0, root1, root;
+
+    /* choose U, V so that U,V,F is orthonormal set */
+
+    if ( fabs(F.x) > fabs(F.y) && fabs(F.x) > fabs(F.z) )
+    {
+        length = sqrt(F.x*F.x+F.y*F.y);
+        invLength = 1.0/length;
+        U.x = -F.y*invLength;
+        U.y = +F.x*invLength;
+        U.z = 0.0;
+        prod = -F.z*invLength;
+        V.x = F.x*prod;
+        V.y = F.y*prod;
+        V.z = length;
+    }
+    else
+    {
+        length = sqrt(F.y*F.y+F.z*F.z);
+        invLength = 1.0/length;
+        U.x = 0.0;
+        U.y = -F.z*invLength;
+        U.z = +F.y*invLength;
+        prod = -F.x*invLength;
+        V.x = length;
+        V.y = F.y*prod;
+        V.z = F.z*prod;
+    }
+
+    /* orthonormal matrix */
+    R[0][0] = U.x;  R[0][1] = U.y;  R[0][2] = U.z;
+    R[1][0] = V.x;  R[1][1] = V.y;  R[1][2] = V.z;
+    R[2][0] = F.x;  R[2][1] = F.y;  R[2][2] = F.z;
+
+    /* matrix A */
+    A[0][0] = R[0][0]*R[0][0]+R[1][0]*R[1][0];
+    A[0][1] = R[0][0]*R[0][1]+R[1][0]*R[1][1];
+    A[0][2] = R[0][0]*R[0][2]+R[1][0]*R[1][2];
+
+    A[1][0] = R[0][1]*R[0][0]+R[1][1]*R[1][0];
+    A[1][1] = R[0][1]*R[0][1]+R[1][1]*R[1][1];
+    A[1][2] = R[0][1]*R[0][2]+R[1][1]*R[1][2];
+
+    A[2][0] = R[0][2]*R[0][0]+R[1][2]*R[1][0];
+    A[2][1] = R[0][2]*R[0][1]+R[1][2]*R[1][1];
+    A[2][2] = R[0][2]*R[0][2]+R[1][2]*R[1][2];
+
+    /* vector B */
+    P = Vector3(0.0, 0.0, 0.0);
+    B.x = -2.0*P.x;  B.y = -2.0*P.y;  B.z = -2.0*P.z;
+
+    /* constant C */
+    e0 = -2.0*(R[0][0]*P.x+R[0][1]*P.y+R[0][2]*P.z);
+    e1 = -2.0*(R[1][0]*P.x+R[1][1]*P.y+R[1][2]*P.z);
+    C = 0.25*(e0*e0+e1*e1) - radius*radius;
+
+    /* line */
+    Q = ray.getOrigin().sub(axis.getOrigin());
+    G = ray.getDirection();
+
+    /* compute A*G */
+    AG.x = A[0][0]*G.x+A[0][1]*G.y+A[0][2]*G.z;
+    AG.y = A[1][0]*G.x+A[1][1]*G.y+A[1][2]*G.z;
+    AG.z = A[2][0]*G.x+A[2][1]*G.y+A[2][2]*G.z;
+
+    /* compute A*Q */
+    AQ.x = A[0][0]*Q.x+A[0][1]*Q.y+A[0][2]*Q.z;
+    AQ.y = A[1][0]*Q.x+A[1][1]*Q.y+A[1][2]*Q.z;
+    AQ.z = A[2][0]*Q.x+A[2][1]*Q.y+A[2][2]*Q.z;
+
+    /* compute quadratic equation c0+c1*t+c2*t^2 = 0 */
+    c2 = G.x*AG.x+G.y*AG.y+G.z*AG.z;
+    c1 = B.x*G.x+B.y*G.y+B.z*G.z+2.0f*(Q.x*AG.x+Q.y*AG.y+Q.z*AG.z);
+    c0 = Q.x*AQ.x+Q.y*AQ.y+Q.z*AQ.z+B.x*Q.x+B.y*Q.y+B.z*Q.z+C;
+
+    /* solve for intersections */
+    int numIntersections;
+    discr = c1*c1-4.0*c0*c2;
+    if ( discr > EPS )
+    {
+        numIntersections = 2;
+        discr = sqrt(discr);
+        invC2 = 1.0/c2;
+        root0 = -0.5*(c1+discr)*invC2;
+        root1 = -0.5*(c1-discr)*invC2;
+        first_intersection->x = Q.x+root0*G.x;
+        first_intersection->y = Q.y+root0*G.y;
+        first_intersection->z = Q.z+root0*G.z;
+        second_intersection->x = Q.x+root1*G.x;
+        second_intersection->y = Q.y+root1*G.y;
+        second_intersection->z = Q.z+root1*G.z;
+
+        *first_intersection = first_intersection->add(axis.getOrigin());
+        *second_intersection = second_intersection->add(axis.getOrigin());
+    }
+    else if ( discr < -EPS )
+    {
+        numIntersections = 0;
+    }
+    else
+    {
+        numIntersections = 1;
+        root = -0.5*c1/c2;
+        first_intersection->x = Q.x+root*G.x;
+        first_intersection->y = Q.y+root*G.y;
+        first_intersection->z = Q.z+root*G.z;
+
+        *first_intersection = first_intersection->add(axis.getOrigin());
+    }
+
+    return numIntersections;
+}
+
+void InfiniteCylinder::save(PackStream *stream) const
+{
+    axis.save(stream);
+    stream->write(&radius);
+}
+
+void InfiniteCylinder::load(PackStream *stream)
+{
+    axis.load(stream);
+    stream->read(&radius);
+}

src/basics/InfiniteCylinder.h

@@ -0,0 +1,41 @@
+#ifndef INFINITECYLINDER_H
+#define INFINITECYLINDER_H
+
+#include "basics_global.h"
+
+#include "InfiniteRay.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Geometric cylinder, with infinite length.
+ */
+class BASICSSHARED_EXPORT InfiniteCylinder
+{
+public:
+    InfiniteCylinder();
+    InfiniteCylinder(const InfiniteRay &axis, double radius);
+
+    inline const InfiniteRay& getAxis() const {return axis;}
+    inline double getRadius() const {return radius;}
+
+    /**
+     * Check the intersection between the cylinder and an infinite ray.
+     *
+     * Returns the number of intersections (0, 1 or 2) and fill the intersection points.
+     */
+    int checkRayIntersection(const InfiniteRay& ray, Vector3 *first_intersection, Vector3 *second_intersection) const;
+
+    virtual void save(PackStream *stream) const;
+    virtual void load(PackStream *stream);
+
+protected:
+    InfiniteRay axis;
+    double radius;
+};
+
+}
+}
+
+#endif // INFINITECYLINDER_H

src/basics/InfinitePlane.cpp

@@ -0,0 +1,48 @@
+#include "InfinitePlane.h"
+
+#include "PackStream.h"
+#include "InfiniteRay.h"
+
+InfinitePlane::InfinitePlane()
+{
+}
+
+InfinitePlane::InfinitePlane(const Vector3 &point, const Vector3 &normal):
+    point(point), normal(normal)
+{
+}
+
+int InfinitePlane::checkRayIntersection(const InfiniteRay &ray, Vector3 *intersection) const
+{
+    Vector3 p1 = ray.getDirection();
+    double d = normal.dotProduct(p1);
+
+    if (fabs(d) < 1e-8)
+    {
+        if (normal.dotProduct(ray.getPointAtCursor(1.0).sub(point)) == 0)
+        {
+            return -1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    double u = point.sub(ray.getOrigin()).dotProduct(normal) / d;
+    *intersection = ray.getPointAtCursor(u);
+    return 1;
+}
+
+void InfinitePlane::save(PackStream *stream) const
+{
+    point.save(stream);
+    normal.save(stream);
+}
+
+void InfinitePlane::load(PackStream *stream)
+{
+    point.load(stream);
+    normal.load(stream);
+}
+

src/basics/InfinitePlane.h

@@ -0,0 +1,43 @@
+#ifndef INFINITEPLANE_H
+#define INFINITEPLANE_H
+
+#include "basics_global.h"
+
+#include "Vector3.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Infinite 3d geometric plane.
+ */
+class BASICSSHARED_EXPORT InfinitePlane
+{
+public:
+    InfinitePlane();
+    InfinitePlane(const Vector3 &point, const Vector3 &normal);
+
+    /**
+     * Check the intersection between the plane and an infinite ray.
+     *
+     * Returns the number of intersections (0, 1), and fill the intersection point.
+     *
+     * Returns -1 if the ray is on the plane, and make for an infinite number of intersection points.
+     */
+    int checkRayIntersection(const InfiniteRay& ray, Vector3 *intersection) const;
+
+    inline const Vector3 &getPoint() const {return point;}
+    inline const Vector3 &getNormal() const {return normal;}
+
+    virtual void save(PackStream *stream) const;
+    virtual void load(PackStream *stream);
+
+private:
+    Vector3 point;
+    Vector3 normal;
+};
+
+}
+}
+
+#endif // INFINITEPLANE_H

src/basics/InfiniteRay.cpp

@@ -0,0 +1,27 @@
+#include "InfiniteRay.h"
+
+InfiniteRay::InfiniteRay()
+{
+}
+
+InfiniteRay::InfiniteRay(const Vector3 &origin, const Vector3 &direction):
+    origin(origin), direction(direction.normalize())
+{
+}
+
+InfiniteRay InfiniteRay::fromPoints(const Vector3 &point1, const Vector3 &point2)
+{
+    return InfiniteRay(point1, point2.sub(point1).normalize());
+}
+
+void InfiniteRay::save(PackStream *stream) const
+{
+    origin.save(stream);
+    direction.save(stream);
+}
+
+void InfiniteRay::load(PackStream *stream)
+{
+    origin.load(stream);
+    direction.load(stream);
+}

src/basics/InfiniteRay.h

@@ -0,0 +1,39 @@
+#ifndef INFINITERAY_H
+#define INFINITERAY_H
+
+#include "basics_global.h"
+
+#include "Vector3.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Infinite ray (line).
+ */
+class BASICSSHARED_EXPORT InfiniteRay
+{
+public:
+    InfiniteRay();
+    InfiniteRay(const Vector3 &origin, const Vector3 &direction);
+
+    static InfiniteRay fromPoints(const Vector3 &point1, const Vector3 &point2);
+
+    inline const Vector3 &getOrigin() const {return origin;}
+    inline const Vector3 &getDirection() const {return direction;}
+
+    inline double getCursor(const Vector3 &point) const {return point.sub(origin).dotProduct(direction);}
+    inline Vector3 getPointAtCursor(double distance) const {return origin.add(direction.scale(distance));}
+
+    void save(PackStream *stream) const;
+    void load(PackStream *stream);
+
+private:
+    Vector3 origin;
+    Vector3 direction;
+};
+
+}
+}
+
+#endif // INFINITERAY_H

src/basics/Sphere.cpp

@@ -0,0 +1,62 @@
+#include "Sphere.h"
+
+#include "PackStream.h"
+#include "InfiniteRay.h"
+
+Sphere::Sphere()
+{
+}
+
+Sphere::Sphere(const Vector3 &center, double radius):
+    center(center), radius(radius)
+{
+    radius2 = radius * radius;
+}
+
+int Sphere::checkRayIntersection(const InfiniteRay &ray, Vector3 *first_intersection, Vector3 *second_intersection) const
+{
+    Vector3 L = ray.getOrigin().sub(center);
+    double b = 2.0 * ray.getDirection().dotProduct(L);
+    double c = L.dotProduct(L) - radius2;
+
+    double discr = b * b - 4.0 * c;
+    if (discr < 0)
+    {
+        return 0;
+    }
+    else if (discr == 0)
+    {
+        *first_intersection = ray.getPointAtCursor(-0.5 * b);
+        return 1;
+    }
+    else
+    {
+        double x0 = (b > 0.0) ? -0.5 * (b + sqrt(discr)) : -0.5 * (b - sqrt(discr));
+        double x1 = c / x0;
+        if (x0 > x1)
+        {
+            *first_intersection = ray.getPointAtCursor(x1);
+            *second_intersection = ray.getPointAtCursor(x0);
+        }
+        else
+        {
+            *first_intersection = ray.getPointAtCursor(x0);
+            *second_intersection = ray.getPointAtCursor(x1);
+        }
+        return 2;
+    }
+}
+
+void Sphere::save(PackStream *stream) const
+{
+    center.save(stream);
+    stream->write(&radius);
+    stream->write(&radius2);
+}
+
+void Sphere::load(PackStream *stream)
+{
+    center.load(stream);
+    stream->read(&radius);
+    stream->read(&radius2);
+}

src/basics/Sphere.h

@@ -0,0 +1,42 @@
+#ifndef SPHERE_H
+#define SPHERE_H
+
+#include "basics_global.h"
+
+#include "Vector3.h"
+
+namespace paysages {
+namespace basics {
+
+/**
+ * Geometric sphere.
+ */
+class BASICSSHARED_EXPORT Sphere
+{
+public:
+    Sphere();
+    Sphere(const Vector3 &center, double radius);
+
+    inline const Vector3 &getCenter() const {return center;}
+    inline const double &getRadius() const {return radius;}
+
+    /**
+     * Check the intersection between the sphere and an infinite ray.
+     *
+     * Returns the number of intersections (0, 1 or 2) and fill the intersection points.
+     */
+    int checkRayIntersection(const InfiniteRay& ray, Vector3 *first_intersection, Vector3 *second_intersection) const;
+
+    void save(PackStream *stream) const;
+    void load(PackStream *stream);
+
+private:
+    Vector3 center;
+    double radius;
+    double radius2;
+};
+
+}
+}
+
+#endif // SPHERE_H

src/basics/basics.pro

@@ -34,6 +34,12 @@ SOURCES += \
     Texture4D.cpp \
     NoiseState.cpp \
     FractalNoise.cpp \
+    CappedCylinder.cpp \
+    InfiniteCylinder.cpp \
+    InfiniteRay.cpp \
+    Sphere.cpp \
+    InfinitePlane.cpp \
+    Disk.cpp \
     SpaceGridIterator.cpp
 
 HEADERS +=\
@@ -56,6 +62,12 @@ HEADERS +=\
     Texture4D.h \
     NoiseState.h \
     FractalNoise.h \
+    CappedCylinder.h \
+    InfiniteCylinder.h \
+    InfiniteRay.h \
+    Sphere.h \
+    InfinitePlane.h \
+    Disk.h \
     SpaceGridIterator.h
 
 unix:!symbian {

src/basics/basics_global.h

@@ -26,6 +26,10 @@ namespace basics {
     class Texture2D;
     class Texture3D;
     class Texture4D;
+    class CappedCylinder;
+    class InfiniteRay;
+    class Sphere;
+    class InfinitePlane;
 }
 }
 using namespace paysages::basics;

src/tests/CappedCylinder_Test.cpp

@@ -0,0 +1,38 @@
+#include "BaseTestCase.h"
+
+#include "CappedCylinder.h"
+
+TEST(CappedCylinder, checkRayIntersection)
+{
+    CappedCylinder cylinder(VECTOR_DOWN, VECTOR_UP, 1.0, 2.0);
+
+    int intersect_count;
+    Vector3 p1, p2;
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(1.5, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(0, intersect_count);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(1, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 1.0, 0.0, 0.0);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(0.5, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(2, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 0.5, 0.0, -cos(asin(0.5)));
+    EXPECT_VECTOR3_COORDS(p2, 0.5, 0.0, cos(asin(0.5)));
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(0.5, -2.1, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(0, intersect_count);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(0.5, 2.1, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(0, intersect_count);
+
+    // diagonal cases (through a cap)
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(-2.0, -1.0, 0.0), Vector3(1.0, 1.0, 0.0)), &p1, &p2);
+    EXPECT_EQ(1, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, -1.0, 0.0, 0.0);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(-2.0, 3.0, 0.0), Vector3(1.0, -1.0, 0.0)), &p1, &p2);
+    EXPECT_EQ(1, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 1.0, 0.0, 0.0);
+}

src/tests/Disk_Test.cpp

@@ -0,0 +1,25 @@
+#include "BaseTestCase.h"
+
+#include "InfiniteRay.h"
+#include "Disk.h"
+
+TEST(Disk, checkRayIntersection)
+{
+    Disk disk(VECTOR_UP, VECTOR_UP, 0.8);
+
+    int result;
+    Vector3 point;
+
+    result = disk.checkRayIntersection(InfiniteRay(Vector3(0.0, 2.0, 0.0), VECTOR_SOUTH), &point);
+    ASSERT_EQ(0, result);
+
+    result = disk.checkRayIntersection(InfiniteRay(Vector3(1.5, 2.0, -1.0), VECTOR_DOWN), &point);
+    ASSERT_EQ(0, result);
+
+    result = disk.checkRayIntersection(InfiniteRay(Vector3(0.5, 2.0, 0.0), VECTOR_DOWN), &point);
+    ASSERT_EQ(1, result);
+    EXPECT_VECTOR3_COORDS(point, 0.5, 1.0, 0.0);
+
+    result = disk.checkRayIntersection(InfiniteRay(Vector3(1.0, 1.0, 0.0), VECTOR_EAST), &point);
+    ASSERT_EQ(-1, result);
+}

src/tests/InfiniteCylinder_Test.cpp

@@ -0,0 +1,41 @@
+#include "BaseTestCase.h"
+
+#include "InfiniteRay.h"
+#include "InfiniteCylinder.h"
+#include <cmath>
+
+TEST(InfiniteCylinder, checkRayIntersection)
+{
+    InfiniteRay ray(VECTOR_ZERO, VECTOR_UP);
+    InfiniteCylinder cylinder(ray, 1.0);
+
+    int intersect_count;
+    Vector3 p1, p2;
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(1.5, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(0, intersect_count);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(1.0, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(1, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 1.0, 0.0, 0.0);
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay(Vector3(0.5, 0.0, 0.0), Vector3(0.0, 0.0, 1.0)), &p1, &p2);
+    EXPECT_EQ(2, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 0.5, 0.0, -cos(asin(0.5)));
+    EXPECT_VECTOR3_COORDS(p2, 0.5, 0.0, cos(asin(0.5)));
+}
+
+TEST(InfiniteCylinder, checkRayIntersection2)
+{
+    InfiniteRay ray(Vector3(-1.4, 1.5, 1.0), Vector3(1.0, 0.0, 0.0));
+    InfiniteCylinder cylinder(ray, 0.5);
+
+    int intersect_count;
+    Vector3 p1, p2;
+
+    intersect_count = cylinder.checkRayIntersection(InfiniteRay::fromPoints(Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.5, 2.0)), &p1, &p2);
+    EXPECT_EQ(2, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 0.0, 1.5, 0.5);
+    EXPECT_VECTOR3_COORDS(p2, 0.0, 1.5, 1.5);
+}
+

src/tests/InfinitePlane_Test.cpp

@@ -0,0 +1,34 @@
+#include "BaseTestCase.h"
+
+#include "InfiniteRay.h"
+#include "InfinitePlane.h"
+
+TEST(InfinitePlane, checkRayIntersection)
+{
+    InfinitePlane plane(VECTOR_UP, VECTOR_UP);
+
+    int result;
+    Vector3 point;
+
+    result = plane.checkRayIntersection(InfiniteRay(Vector3(0.0, 2.0, 0.0), VECTOR_SOUTH), &point);
+    ASSERT_EQ(0, result);
+
+    result = plane.checkRayIntersection(InfiniteRay(Vector3(1.5, 2.0, -1.0), VECTOR_DOWN), &point);
+    ASSERT_EQ(1, result);
+    EXPECT_VECTOR3_COORDS(point, 1.5, 1.0, -1.0);
+
+    result = plane.checkRayIntersection(InfiniteRay(Vector3(1.0, 1.0, 0.0), VECTOR_EAST), &point);
+    ASSERT_EQ(-1, result);
+}
+
+TEST(InfinitePlane, checkRayIntersection_oblique)
+{
+    InfinitePlane plane(Vector3(14.0, -5.0, 3.5), Vector3(1.0, 0.0, 0.0));
+    InfiniteRay ray(Vector3(2.0, 2.0, 2.0), Vector3(1.0, 1.0, 1.0).normalize());
+    int result;
+    Vector3 point;
+
+    result = plane.checkRayIntersection(ray, &point);
+    ASSERT_EQ(1, result);
+    EXPECT_VECTOR3_COORDS(point, 14.0, 14.0, 14.0);
+}

src/tests/Sphere_Test.cpp

@@ -0,0 +1,24 @@
+#include "BaseTestCase.h"
+
+#include "InfiniteRay.h"
+#include "Sphere.h"
+
+TEST(Sphere, checkRayIntersection)
+{
+    Sphere sphere(Vector3(2.0, 1.0, 1.0), 0.5);
+
+    int intersect_count;
+    Vector3 p1, p2;
+
+    intersect_count = sphere.checkRayIntersection(InfiniteRay(Vector3(0.0, 0.0, 0.0), VECTOR_SOUTH), &p1, &p2);
+    ASSERT_EQ(0, intersect_count);
+
+    intersect_count = sphere.checkRayIntersection(InfiniteRay(Vector3(1.5, 1.0, 0.0), VECTOR_SOUTH), &p1, &p2);
+    ASSERT_EQ(1, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 1.5, 1.0, 1.0);
+
+    intersect_count = sphere.checkRayIntersection(InfiniteRay(Vector3(2.0, 1.0, 0.0), VECTOR_SOUTH), &p1, &p2);
+    ASSERT_EQ(2, intersect_count);
+    EXPECT_VECTOR3_COORDS(p1, 2.0, 1.0, 0.5);
+    EXPECT_VECTOR3_COORDS(p2, 2.0, 1.0, 1.5);
+}

src/tests/tests.pro

@@ -34,6 +34,11 @@ SOURCES += main.cpp \
     GodRaysSampler_Test.cpp \
     Interpolation_Test.cpp \
     Rasterizer_Test.cpp \
+    CappedCylinder_Test.cpp \
+    InfiniteCylinder_Test.cpp \
+    Sphere_Test.cpp \
+    InfinitePlane_Test.cpp \
+    Disk_Test.cpp \
     Vector3_Test.cpp
 
 HEADERS += \