bool FloorFace::intersectRay(const Math::Ray &ray, Math::Vector3d &intersection) const {
	// Compute the triangle plane normal
	Math::Vector3d n = Math::Vector3d::crossProduct(_vertices[1] - _vertices[0],  _vertices[2] - _vertices[0]);
	if (n == Math::Vector3d()) {
		return false; // We don't handle degenerate triangles
	}

	// Point on triangle plane: dot(P - _vertices[0], n) = 0
	// Point on ray: P = origin + r * direction
	// Point on both => r = - dot(n, origin - _vertices[0]) / dot(n, direction)

	float num = -Math::Vector3d::dotProduct(n, ray.origin() - _vertices[0]);
	float denom = Math::Vector3d::dotProduct(n, ray.direction());

	if (fabs(denom) < 0.00001) {
		// The ray is parallel to the plane
		return false;
	}

	float r = num / denom;
	if (r < 0.0) {
		// The ray goes away from the triangle
		return false;
	}

	// Compute the intersection point between the triangle plane and the ray
	intersection = ray.origin() + r * ray.direction();

	// Check the intersection point is inside the triangle
	return isPointInside(intersection);
}
Exemple #2
0
bool static rayIntersectsRect(const Math::Ray &ray, const Math::Vector3d &topLeft, const Math::Vector3d &topRight,
                              const Math::Vector3d &bottomLeft, const Math::Vector3d &bottomRight) {
	// Orthogonal basis in rectangle coordinates
	Math::Vector3d topRectDir = topRight - topLeft;
	Math::Vector3d leftRectDir = bottomLeft - topLeft;
	Math::Vector3d n = Math::Vector3d::crossProduct(topRectDir, leftRectDir);

	float nDotDir = Math::Vector3d::dotProduct(n, ray.getDirection());
	if (ABS(nDotDir) < 1e-6) {
		// The ray is coplanar with the rectangle
		return false;
	}

	// Solution to the system (intersection of line with plane):
	// Line equation: V = ray.origin + t * ray.direction
	// Plane equation: dot(n, V) = 0
	float t = -Math::Vector3d::dotProduct(n, ray.getOrigin() - topLeft) / nDotDir;

	if (t < 0.0) {
		// The intersection is not in the ray direction
		return false;
	}

	// Intersection point in world coordinates
	Math::Vector3d intersection = ray.getOrigin() + ray.getDirection() * t;

	// Intersection point in 2D rect coordinates
	Math::Vector3d intersect2D = intersection - topLeft;
	float u = Math::Vector3d::dotProduct(intersect2D, topRectDir);
	float v = Math::Vector3d::dotProduct(intersect2D, leftRectDir);

	// Intersection inside the rectangle
	return (u >= 0.0 && u <= Math::Vector3d::dotProduct(topRectDir, topRectDir)
	        && v >= 0.0 && v <= Math::Vector3d::dotProduct(leftRectDir, leftRectDir));
}
Exemple #3
0
bool BoneNode::intersectRay(const Math::Ray &ray) const {
	Math::Ray localRay = ray;
	localRay.translate(-_animPos);
	localRay.rotate(_animRot.inverse());

	return localRay.intersectAABB(_boundingBox);
}
Exemple #4
0
bool VisualActor::intersectRay(const Math::Ray &ray, const Math::Vector3d position, float direction) {
	Math::Matrix4 inverseModelMatrix = getModelMatrix(position, direction);
	inverseModelMatrix.inverse();

	// Build an object local ray from the world ray
	Math::Ray localRay = ray;
	localRay.transform(inverseModelMatrix);

	return _model->intersectRay(localRay);
}
Exemple #5
0
 bool BoundingEllipsoid::intersects (math::Ray &r, bool segment, CollisionResultSet::Info& info) {
     math::Matrix4f transform = scale * rotation * translation;
     math::Matrix4f invTransform = transform.inverse();
     math::Vec3f orig = invTransform * r.getOrig();
     math::Vec3f ext = invTransform * r.getExt();
     math::Ray tRay (orig, ext);
     math::Vec3f mtu;
     BoundingSphere bs(math::Vec3f(0, 0, 0), 1);
     if (!bs.intersects(tRay, segment, info))
         return false;
     return false;
 }
Exemple #6
0
 bool BoundingEllipsoid::intersectsWhere(math::Ray& r, math::Vec3f& near, math::Vec3f& far, CollisionResultSet::Info& info) {
     math::Matrix4f transform = scale * rotation * translation;
     math::Matrix4f invTransform = transform.inverse();
     math::Vec3f orig = invTransform * r.getOrig();
     math::Vec3f ext = invTransform * r.getExt();
     math::Ray tRay (orig, ext);
     math::Vec3f i1, i2;
     BoundingSphere bs(math::Vec3f(0, 0, 0), 1);
     if (!bs.intersectsWhere(tRay, i1, i2, info))
         return false;
     near = transform * i1;
     far = transform * i2;
     return true;
 }
Exemple #7
0
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
//see http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=4152&hilit=raytest
//for reference
void 
PhysicsZone::rayCast(Math::Ray _ray, Math::Real _maxDistance, I_CollisionVisitor& _visitor)
{
    Math::Vector3 offset = _ray.getDirection();
    offset.normalize();
    offset *= _maxDistance;
    Math::Point3 endpoint = _ray.getOrigin() + offset;

    //(m_pZone, _ray.getOrigin().m_array, endpoint.m_array, rayCastFilter, &rayCastQuery, rayCastPrefilter);

    btVector3 tquatFrom = btVector3(_ray.getOrigin().m_x,_ray.getOrigin().m_y,_ray.getOrigin().m_z);
    btVector3 tquatTo = btVector3(_ray.getOrigin().m_x,_ray.getOrigin().m_y,_ray.getOrigin().m_z);

	RayResultCallback	resultCallback(tquatFrom,tquatTo);
   
	m_pZone->rayTest(tquatFrom,tquatTo,resultCallback);
}
Exemple #8
0
        void BVHSceneTree::findIntersections(BVHSceneNode* node, Math::Ray const& ray, std::vector<std::pair<SceneObject*, float>>& objects) const
        {
            if(node)
            {
                Math::Vector3f point;
                float distance;

                if(ray.intersects(node->bounds, point, distance))
                {
                    if((node->type == SceneNodeType::Leaf) && (node->object))
                    {
                        objects.emplace_back(std::make_pair(node->object, distance));
                    }
                    else
                    {
                        findIntersections(node->left, ray, objects);
                        findIntersections(node->right, ray, objects);
                    }
                }
            }
        }
Exemple #9
0
  bool Planet::get_color(ColorRGBA& resulting_color, const Vector2& screen, Math::Ray ray, gfloat& distance)const
  {
    if(sphere.radius<=0.f)
      return false;

    ray.transform(sphere.inv_transformation);
    if(!sphere.intersects_local(ray, distance))
      return false;

    Vector3 p = ray.origin + ray.dir*distance;
    p.normalize();
    p *= sphere.radius;

    Vector3 normal = p;
    normal *= 1.f/sphere.radius;

    if(Manager::get_settings().get_dbg_normal())
    {
      resulting_color.set_direction(normal);
    }else
    {
      Vector2 uv;

      vec_to_uv(uv, normal);

      if(Manager::get_settings().get_dbg_uv())
      {
        resulting_color.set(uv.x, uv.y, 0.f, 1.f);
      }else
      {
        shader(resulting_color, screen, uv, normal, ray);
      }
    }

    return true;
  }
Exemple #10
0
float FloorFace::distanceToRay(const Math::Ray &ray) const {
	Math::Vector3d center = getCenter();
	return Math::Vector3d::crossProduct(ray.direction(), center - ray.origin()).getMagnitude();
}