fixed bounding volume issue

[laserbrain_demo] / src / geom.cc

diff --git a/src/geom.cc b/src/geom.cc
index 0a82566..5fc3dce 100644 (file)
--- a/src/geom.cc
+++ b/src/geom.cc
@@ -1,6 +1,7 @@
 #include <algorithm>
 #include <float.h>
 #include "geom.h"
+#include "app.h"
 
 #define SPHERE(ptr)    ((Sphere*)ptr)
 #define AABOX(ptr)     ((AABox*)ptr)
@@ -16,6 +17,15 @@ GeomObject::~GeomObject()
 {
 }
 
+bool GeomObject::valid() const
+{
+       return true;
+}
+
+void GeomObject::invalidate()
+{
+}
+
 
 Sphere::Sphere()
 {
@@ -30,6 +40,17 @@ Sphere::Sphere(const Vec3 &cent, float radius)
        this->radius = radius;
 }
 
+bool Sphere::valid() const
+{
+       return radius >= 0.0f;
+}
+
+void Sphere::invalidate()
+{
+       center = Vec3(0, 0, 0);
+       radius = -1;
+}
+
 bool Sphere::intersect(const Ray &ray, HitPoint *hit) const
 {
        float a = dot(ray.dir, ray.dir);
@@ -94,19 +115,41 @@ AABox::AABox(const Vec3 &vmin, const Vec3 &vmax)
        type = GOBJ_AABOX;
 }
 
+bool AABox::valid() const
+{
+       return min.x <= max.x && min.y <= max.y && min.z <= max.z;
+}
+
+void AABox::invalidate()
+{
+       min = Vec3(FLT_MAX, FLT_MAX, FLT_MAX);
+       max = Vec3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+}
+
 Vec3 AABox::get_corner(int idx) const
 {
-       static const Vec3 v[] = {
-               Vec3(-0.5, -0.5, -0.5), Vec3(0.5, -0.5, -0.5), Vec3(0.5, -0.5, 0.5), Vec3(-0.5, -0.5, 0.5),
-               Vec3(-0.5, 0.5, -0.5), Vec3(0.5, 0.5, -0.5), Vec3(0.5, 0.5, 0.5), Vec3(-0.5, 0.5, 0.5)
-       };
-       return v[idx] * Vec3(max - min);
+       Vec3 v[] = {min, max};
+       static const int xidx[] = {0, 1, 1, 0, 0, 1, 1, 0};
+       static const int yidx[] = {0, 0, 0, 0, 1, 1, 1, 1};
+       static const int zidx[] = {0, 0, 1, 1, 0, 0, 1, 1};
+       return Vec3(v[xidx[idx]].x, v[yidx[idx]].y, v[zidx[idx]].z);
 }
 
 bool AABox::intersect(const Ray &ray, HitPoint *hit) const
 {
        Vec3 param[2] = {min, max};
+#ifndef NDEBUG
+       Vec3 inv_dir;
+       if(fpexcept_enabled) {
+               inv_dir.x = ray.dir.x == 0.0f ? 1.0f : 1.0f / ray.dir.x;
+               inv_dir.y = ray.dir.y == 0.0f ? 1.0f : 1.0f / ray.dir.y;
+               inv_dir.z = ray.dir.z == 0.0f ? 1.0f : 1.0f / ray.dir.z;
+       } else {
+               inv_dir = Vec3(1.0 / ray.dir.x, 1.0 / ray.dir.y, 1.0 / ray.dir.z);
+       }
+#else
        Vec3 inv_dir(1.0 / ray.dir.x, 1.0 / ray.dir.y, 1.0 / ray.dir.z);
+#endif
        int sign[3] = {inv_dir.x < 0, inv_dir.y < 0, inv_dir.z < 0};
 
        float tmin = (param[sign[0]].x - ray.origin.x) * inv_dir.x;
@@ -186,28 +229,39 @@ float AABox::signed_distance(const Vec3 &v) const
 
 Box::Box()
 {
+       type = GOBJ_BOX;
 }
 
 Box::Box(const AABox &aabox, const Mat4 &xform)
        : xform(xform)
 {
+       type = GOBJ_BOX;
        min = aabox.min;
        max = aabox.max;
 }
 
+void Box::invalidate()
+{
+       AABox::invalidate();
+       xform = Mat4::identity;
+}
+
 Box::Box(const Vec3 &min, const Vec3 &max)
        : AABox(min, max)
 {
+       type = GOBJ_BOX;
 }
 
 Box::Box(const Vec3 &min, const Vec3 &max, const Mat4 &xform)
        : AABox(min, max), xform(xform)
 {
+       type = GOBJ_BOX;
 }
 
 // XXX all this shit is completely untested
 Box::Box(const Vec3 &pos, const Vec3 &vi, const Vec3 &vj, const Vec3 &vk)
 {
+       type = GOBJ_BOX;
        float ilen = length(vi);
        float jlen = length(vj);
        float klen = length(vk);
@@ -225,17 +279,13 @@ Box::Box(const Vec3 &pos, const Vec3 &vi, const Vec3 &vj, const Vec3 &vk)
 
 Box::Box(const Vec3 *varr, int vcount)
 {
+       type = GOBJ_BOX;
        calc_bounding_aabox(this, varr, vcount);
 }
 
 Vec3 Box::get_corner(int idx) const
 {
-       static const Vec3 v[] = {
-               Vec3(-0.5, -0.5, -0.5), Vec3(0.5, -0.5, -0.5), Vec3(0.5, -0.5, 0.5), Vec3(-0.5, -0.5, 0.5),
-               Vec3(-0.5, 0.5, -0.5), Vec3(0.5, 0.5, -0.5), Vec3(0.5, 0.5, 0.5), Vec3(-0.5, 0.5, 0.5)
-       };
-
-       return xform * (v[idx] * Vec3(max - min));
+       return xform * AABox::get_corner(idx);
 }
 
 bool Box::intersect(const Ray &ray, HitPoint *hit) const
@@ -274,22 +324,26 @@ float Box::signed_distance(const Vec3 &v) const
 Plane::Plane()
        : normal(0.0, 1.0, 0.0)
 {
+       type = GOBJ_PLANE;
 }
 
 Plane::Plane(const Vec3 &p, const Vec3 &norm)
        : pt(p)
 {
+       type = GOBJ_PLANE;
        normal = normalize(norm);
 }
 
 Plane::Plane(const Vec3 &p1, const Vec3 &p2, const Vec3 &p3)
        : pt(p1)
 {
+       type = GOBJ_PLANE;
        normal = normalize(cross(p2 - p1, p3 - p1));
 }
 
 Plane::Plane(const Vec3 &normal, float dist)
 {
+       type = GOBJ_PLANE;
        this->normal = normalize(normal);
        pt = this->normal * dist;
 }
@@ -331,21 +385,34 @@ float Plane::signed_distance(const Vec3 &v) const
 
 Disc::Disc()
 {
+       type = GOBJ_DISC;
        radius = 1.0;
 }
 
 Disc::Disc(const Vec3 &pt, const Vec3 &normal, float rad)
        : Plane(pt, normal)
 {
+       type = GOBJ_DISC;
        radius = rad;
 }
 
 Disc::Disc(const Vec3 &normal, float dist, float rad)
        : Plane(normal, dist)
 {
+       type = GOBJ_DISC;
        radius = rad;
 }
 
+bool Disc::valid() const
+{
+       return radius >= 0.0f;
+}
+
+void Disc::invalidate()
+{
+       radius = -1;
+}
+
 bool Disc::intersect(const Ray &ray, HitPoint *hit) const
 {
        HitPoint phit;
@@ -385,6 +452,11 @@ Vec3 proj_point_plane(const Vec3 &pt, const Plane &plane)
 
 bool calc_bounding_sphere(Sphere *sph, const GeomObject *obj)
 {
+       if(!obj->valid()) {
+               sph->invalidate();
+               return true;
+       }
+
        switch(obj->type) {
        case GOBJ_SPHERE:
                *sph = *(Sphere*)obj;
@@ -466,6 +538,11 @@ bool calc_bounding_sphere(Sphere *sph, const Vec3 *v, int num, const Mat4 &xform
 
 bool calc_bounding_aabox(AABox *box, const GeomObject *obj)
 {
+       if(!obj->valid()) {
+               box->invalidate();
+               return true;
+       }
+
        switch(obj->type) {
        case GOBJ_AABOX:
                *box = *(AABox*)obj;
@@ -545,6 +622,11 @@ bool calc_bounding_aabox(AABox *box, const Vec3 *v, int num, const Mat4 &xform)
 
 bool calc_bounding_box(Box *box, const GeomObject *obj)
 {
+       if(!obj->valid()) {
+               box->invalidate();
+               return true;
+       }
+
        switch(obj->type) {
        case GOBJ_BOX:
                *box = *(Box*)obj;