The calculation of collision points between the small box and BVH_OBB is incorrect

[hazidh]

I created a BVH_OBB cube and also created a Box with dimensions (1000, 0.001, 0.001). However, the contact points obtained from their collision were incorrect.

[jorisv]

Hello @hazidh,

Can you provide us a python script to reproduce your issue ?

[hazidh]

Hello @hazidh,

Can you provide us a python script to reproduce your issue ?

@jorisv Hello, I have re-implemented the collision detection between rays and BVH_OBB. I no longer use a Box to represent the ray. I hope this will be helpful. After testing, there were no issues.

void Collision_BVHOBB_Raycast(CollisionObject* collisionObject,CollisionResult* res,
    float ray_originx, float ray_originy, float ray_originz,
    float ray_dirx, float ray_diry, float ray_dirz,
    float max_distance){

	Vec3s ray_origin(ray_originz, ray_originx, ray_originy);
	Vec3s ray_dir(ray_dirz, ray_dirx, ray_diry);

	Transform3s tf = collisionObject->getTransform();

	//将射线从世界坐标转换成局部坐标
	Vec3s local_rayOrigin = tf.inverseTransform(ray_origin);
	Vec3s local_rayDir = (tf.getRotation().inverse() * ray_dir).normalized();

	CollisionGeometry* o1 = collisionObject->collisionGeometryPtr();
	if (o1->getNodeType() != BV_OBB)
	{
		std::cout << "CollisionGeometry is not BV_OBB" << std::endl;
	}
	
	const BVHModel<OBB>* obj1 = static_cast<const BVHModel<OBB>*>(o1);
	BVNode<OBB> rootNode = obj1->getBV(0);
	Collision_BVHOBB_CollisionRecurseRaycast(obj1,tf,rootNode,res, local_rayOrigin, local_rayDir, max_distance);
}

void Collision_BVHOBB_CollisionRecurseRaycast(
     const BVHModel<OBB>* bvhModel,const Transform3s& tf,const BVNode<OBB>& node,CollisionResult* res,
    const Vec3s& local_rayOrigin,
    const Vec3s& local_rayDir,
     float max_distance)
 {
	if (!Collision_BVHOBB_OBBNodeRayCollide(tf,node, local_rayOrigin, local_rayDir, max_distance))
		return;

		
	if (node.isLeaf()) {
         return Collision_BVHOBB_LeafRayCollide(bvhModel,tf,node,res, local_rayOrigin, local_rayDir, max_distance);
    }

	const BVNode<OBB>& leftNode = bvhModel->getBV(node.leftChild());
	const BVNode<OBB>& rightNode = bvhModel->getBV(node.rightChild());
     // Recurse children
     Collision_BVHOBB_CollisionRecurseRaycast(bvhModel,tf,leftNode,res,local_rayOrigin, local_rayDir, max_distance);
	 Collision_BVHOBB_CollisionRecurseRaycast(bvhModel,tf,rightNode,res,local_rayOrigin, local_rayDir, max_distance);
 }

 //OBB与射线碰撞检测
 bool Collision_BVHOBB_OBBNodeRayCollide(const Transform3s& tf,const BVNode<OBB>& node,
	const Vec3s& local_rayOrigin,
     const Vec3s& local_rayDir,
     float max_distance){

	Vec3s delta = node.bv.To - local_rayOrigin;
	Scalar t1, t2;
    Scalar minT = Scalar(0);
    Scalar maxT = std::numeric_limits<Scalar>::max();
	constexpr Scalar EPS = Scalar(1e-20);
	OBB obb = node.bv;

	// 对 OBB 的三个局部轴做 slab 测试
    for (int i = 0; i < 3; ++i)
    {
        const Vec3s axis = obb.axes.col(i);

        Scalar e = axis.dot(delta);
        Scalar f = axis.dot(local_rayDir);

        Scalar extent = obb.extent[i];

        if (std::abs(f) > EPS)
        {
            t1 = (e + extent) / f;
            t2 = (e - extent) / f;

            if (t1 > t2)
                std::swap(t1, t2);

			//射线长度，同一时刻处在所有投影区域，则取交集
            if (t1 > minT) minT = t1;
            if (t2 < maxT) maxT = t2;

            // slab 区间为空 → 不相交
            if (minT > maxT)
                return false;

            // OBB 完全在射线反方向
            if (maxT < 0)
                return false;
        }
        else
        {
            // 射线与该 slab 平行
            if (-e - extent > 0 || -e + extent < 0)
                return false;
        }
    }

	if (maxT < 0)
        return false;

    // 最近交点超过射线最大长度
    if (minT > max_distance)
        return false;

    return true;

 }



 //三角网格与射线碰撞检测
 void Collision_BVHOBB_LeafRayCollide(const BVHModel<OBB>* bvhModel,const Transform3s& tf,const BVNode<OBB>& node,CollisionResult* res,
	const Vec3s& local_rayOrigin,
     const Vec3s& local_rayDir,
     float max_distance){

	int id = node.primitiveId();
	const Triangle32& tri_id = (*bvhModel->tri_indices)[id];
	Vec3s v0 = (*bvhModel->vertices)[tri_id[0]];
	Vec3s v1 = (*bvhModel->vertices)[tri_id[1]];
	Vec3s v2 = (*bvhModel->vertices)[tri_id[2]];

	const Vec3s E1 = v1 - v0;
    const Vec3s E2 = v2 - v0;

	Scalar t,u,v;

    const Vec3s P = local_rayDir.cross(E2);
    Scalar det = E1.dot(P);

    Vec3s T;
    if (det > 0)
    {
        T = local_rayOrigin - v0;
    }
    else
    {
        T = v0 - local_rayOrigin;
        det = -det;
    }

    if (det < Scalar(1e-8))
        return;

    u = T.dot(P);
    if (u < 0 || u > det)
        return;

    const Vec3s Q = T.cross(E1);

    v = local_rayDir.dot(Q);
    if (v < 0 || u + v > det)
        return;

    t = E2.dot(Q);

    const Scalar invDet = 1.0 / det;
    t *= invDet;

	if (t < Scalar(0) || t > max_distance)
        return;

	Contact contact;
	contact.pos = tf.transform(local_rayOrigin + local_rayDir * t);
	contact.b1 = id;
	contact.b2 = -1;
	contact.o1 = bvhModel;
	contact.o2 = nullptr;
	Vec3s normal = (v1 - v0).cross(v2 - v0);
    normal.normalize(); // 单位化
	contact.normal = normal;
	res->addContact(contact);

 }