game loop tweaks; shapes hierarchy defined

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

diff --git a/src/Moof/Aabb.hh b/src/Moof/Aabb.hh
index f3e92ab471c8b48701a19cf8e61a4427c66a46ab..8fcdbc3787114aca620ba3bdf832698d119f66f3 100644 (file)
--- a/src/Moof/Aabb.hh
+++ b/src/Moof/Aabb.hh
@@ -38,6 +38,7 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
        Vector min;
        Vector max;
 
+
        Aabb() {}
 
        Aabb(const Vector& a, const Vector& b)
@@ -45,16 +46,48 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
                init(a, b);
        }
 
-       Aabb(Scalar ax, Scalar ay, Scalar az,
-                       Scalar bx, Scalar by, Scalar bz)
+       Aabb(Scalar x1, Scalar y1, Scalar x2, Scalar y2)
        {
-               Vector a(ax, ay, az);
-               Vector b(bx, by, bz);
+               Vector a(x1, y1);
+               Vector b(x2, y2);
 
                init(a, b);
        }
 
-       void init(const Vector& a, const Vector& b)
+       Aabb(Scalar x1, Scalar y1, Scalar z1, Scalar x2, Scalar y2, Scalar z2)
+       {
+               Vector a(x1, y1, z1);
+               Vector b(x2, y2, z2);
+
+               init(a, b);
+       }
+
+
+       void init(const Vector2& a, const Vector2& b)
+       {
+               if (a[0] < b[0])
+               {
+                       min[0] = a[0];
+                       max[0] = b[0];
+               }
+               else
+               {
+                       min[0] = b[0];
+                       max[0] = a[0];
+               }
+               if (a[1] < b[1])
+               {
+                       min[1] = a[1];
+                       max[1] = b[1];
+               }
+               else
+               {
+                       min[1] = b[1];
+                       max[1] = a[1];
+               }
+       }
+
+       void init(const Vector3& a, const Vector3& b)
        {
                if (a[0] < b[0])
                {
@@ -88,19 +121,17 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
                }
        }
 
+
        Vector getCenter() const
        {
-               return Vector((min[0] + max[0]) / 2.0,
-                                          (min[1] + max[1]) / 2.0,
-                                          (min[2] + max[2]) / 2.0);
+               return (min + max) / 2.0;
        }
 
-       //void getOctant(Aabb& octant, int num) const;
 
        Plane getPlaneXY() const
        {
                Plane plane;
-               plane.normal = Vector(0.0, 0.0, 1.0);
+               plane.normal = Vector3(0.0, 0.0, 1.0);
                plane.d = cml::dot(-plane.normal, getCenter());
                return plane;
        }
@@ -108,7 +139,7 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
        Plane getPlaneXZ() const
        {
                Plane plane;
-               plane.normal = Vector(0.0, 1.0, 0.0);
+               plane.normal = Vector3(0.0, 1.0, 0.0);
                plane.d = cml::dot(-plane.normal, getCenter());
                return plane;
        }
@@ -116,22 +147,21 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
        Plane getPlaneYZ() const
        {
                Plane plane;
-               plane.normal = Vector(1.0, 0.0, 0.0);
+               plane.normal = Vector3(1.0, 0.0, 0.0);
                plane.d = cml::dot(-plane.normal, getCenter());
                return plane;
        }
 
-       /*
-       void getCorners(Vector3 corners[8]) const;
-
-       void encloseVertices(const Vector3 vertices[], unsigned count);
-
-       void draw(Scalar alpha = 0.0) const;
-       bool isVisible(const Frustum& frustum) const;
-       */
 
+       void getCorners(Vector2 corners[4]) const
+       {
+               corners[0][0] = min[0]; corners[0][1] = min[1];
+               corners[1][0] = max[0]; corners[1][1] = min[1];
+               corners[2][0] = max[0]; corners[2][1] = max[1];
+               corners[3][0] = min[0]; corners[3][1] = max[1];
+       }
 
-       void getCorners(Vector corners[8]) const
+       void getCorners(Vector3 corners[8]) const
        {
                corners[0][0] = min[0];
                corners[0][1] = min[1];
@@ -175,45 +205,63 @@ struct Aabb : public Cullable, public Drawable, public Shape<D>
 
        void draw(Scalar alpha = 0.0) const
        {
-               Scalar vertices[] = {min[0], min[1], min[2],
-                                                        min[0], max[1], min[2],
-                                                        max[0], max[1], min[2],
-                                                        max[0], min[1], min[2],
-                                                        min[0], max[1], max[2],
-                                                        min[0], min[1], max[2],
-                                                        max[0], min[1], max[2],
-                                                        max[0], max[1], max[2]};
-
-               GLubyte indices[] = {0, 1, 2, 3,
-                                                        1, 2, 7, 4,
-                                                        3, 0, 5, 6,
-                                                        2, 3, 6, 7,
-                                                        5, 0, 1, 4,
-                                                        4, 5, 6, 7};
-
-               glEnableClientState(GL_VERTEX_ARRAY);
-               glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-               glVertexPointer(3, GL_SCALAR, 0, vertices);
-
-               glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-               Texture::resetBind();
-
-               glDrawElements(GL_QUADS, sizeof(indices), GL_UNSIGNED_BYTE,
-                                          indices);
-
-               glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-               //glDisableClientState(GL_VERTEX_ARRAY);
-
-               glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+               glRect(min[0], min[1], max[0], max[1]);
        }
 
        bool isVisible(const Frustum& frustum) const
        {
-               return frustum.contains(*this);
+               return true;
        }
 };
 
 
+template <>
+inline void Aabb<3>::draw(Scalar alpha) const
+{
+       Scalar vertices[] = {min[0], min[1], min[2],
+                                                min[0], max[1], min[2],
+                                                max[0], max[1], min[2],
+                                                max[0], min[1], min[2],
+                                                min[0], max[1], max[2],
+                                                min[0], min[1], max[2],
+                                                max[0], min[1], max[2],
+                                                max[0], max[1], max[2]};
+
+       GLubyte indices[] = {0, 1, 2, 3,
+                                                1, 2, 7, 4,
+                                                3, 0, 5, 6,
+                                                2, 3, 6, 7,
+                                                5, 0, 1, 4,
+                                                4, 5, 6, 7};
+
+       glEnableClientState(GL_VERTEX_ARRAY);
+       glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+       glVertexPointer(3, GL_SCALAR, 0, vertices);
+
+       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+       Texture::resetBind();
+
+       glDrawElements(GL_QUADS, sizeof(indices), GL_UNSIGNED_BYTE,
+                                  indices);
+
+       glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+       //glDisableClientState(GL_VERTEX_ARRAY);
+
+       glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+}
+
+template <>
+inline bool Aabb<3>::isVisible(const Frustum& frustum) const
+{
+       return frustum.contains(*this);
+}
+
+
+typedef Aabb<2>                Aabb2;
+typedef Aabb2          Rectangle;
+typedef Aabb<3>                Aabb3;
+
+
 } // namespace Mf
 
 #endif // _MOOF_AABB_HH_