if you are on the ground already when doing the test, the line will intersect at near 0.0f on the line. Therefore, ''result'' will be very very very very close to your start position, hence you keep reseting the position of the player to it''s start position (or very near to it).

Instead of just setting "currentPos = targetPos;", also constrain the velocity of the player to the plane, and slide the player onto the plane.

// the movement from start to endVector displacement = end - start;// set the movement along the plane normal to 0, thus making the movement ''slide'' on the planedisplacement -= collider->_plane.Normal * (displacement.Dot(collider->_plane.Normal));// ''slide'' the target position on the planecurrentPos = targetPos + displacement;

you might run into some problems like that (like going though walls), but at least, it''s a start.

to fix most of these, once you found the fist plane intersected, do another test with the targetPos and the constrained displacement. Here is the code, with sliding motion added.

CPlane* CCollision::collide_with_world(const CVector3 &start, const CVector3 &end, CVector3 &result){	CPlane* pNearestCollidedPlane = NULL;	// go through all the polygons, and find the first intersected	Vector3 end2 = end;   	for (std::vector<CPolygon>::iterator collider = _colliders.begin() ; collider != _colliders.end(); ++collider)	{			if (sphere_plane_collision(start, end2, collider->_plane, result))		{			// the intersection distance is shorter thean the previous one found,			// as save it as the potentially closest collision plane			end2 = result;			pNearestCollidedPlane = collider->_plane;		}	}	// return the first intersection found	result = end2;	return pNearestCollidedPlane;}void CPlayer::move(){	// do the velocity stuff	velocity._x = 0.14 * (ux);	velocity._y = gravity.y // negative;	velocity._z = 0.14 * (uz);	// make sure we will catch even the tiniest of collisions	float threshold = 0.00001f;	currentPos -= velocity * threshold;	// prepare the collison test	CVector3 end   = currentPos + velocity;	CVector3 result;	// a bit of friciton when colliding	float friction = 0.1f;	float bounce = 0.0f; // no bouncing	// as long as we find a plane to slide on to...	while (CCollision::collide_with_world(currentPos, end, result) != NULL)	{		// get the nearest intersection parameters, and put the sphere there		currentPos = result;		CVector3 displacement = end - currentPos;				// the ''slide'' vector (components of the movement along the plane normal is removed.		// even add some bounce if you want.		displacement -= collider->_plane.Normal * displacement.Dot(collider->_plane.Normal) * (1.0f + bounce);		// see how far we can slide, add some simple friction :)		end = currentPos + displacement * friction;		// test the world again to see if we can find another plane to slide onto	}	// right, all collisons are done, set the position for the next frame	currentPos = end;}

that should get you going

in what way? you should not bounce off. You should just slide off the walls. bounce is set to 0.0f.

BTW, in
// see how far we can slide, add some simple friction
end = currentPos + displacement * friction;

replace it by
end = currentPos + displacement * (1.0f - friction);



to make sure you understand the algo

1st step
---------

                                                     . wall2                                                    .                         start                     .                           x                      .                            \                    .                             \                  .                              \                .                               \              .                                \            .  wall1                            \          .   ..................................+--------.----+............                            result \      .     | new end                                    \    .      |                                     \          |                                      \         |                                       \        |                                        \       |                                         \      |                                          \     |                                           \    |                                            \   |                                             \  |                                              \ |                                               \|                                                * end

Step 2
------

                                                     . wall2                                                    .                                                   .                                                  .                                                 .                                                .                                               .                                               *. new end                                              /   .wall1                                 result/      . ..................................*--------+--------*..........                                start     .          end                                         .                                               .        

it''s quite simple really. You just project the end point on the wall surface, and do another test, until no collision is found or the ray is very very small.

the bounce and friction are only extra stuff thrown in. If they bother you, set them to 0.0f

Try with only one wall, just a floor. You should just skid along the plane.

in another words, you can do

void CPlayer::move(){	// do the velocity stuff	velocity._x = CVector3(0.14 * (ux), gravity.y, 0.14 * (uz));	// prepare the collison test	CVector3 end = currentPos + velocity;	// find a plane to slide on to	CVector3 result;	CPlane* pCollidedPlane = CCollision::collide_with_world(currentPos, end, result);	// as long as we find a plane to slide on to...	while (pCollidedPlane != NULL)	{		// get the nearest intersection parameters, and put the sphere there		currentPos = result;		// Move the end point on the surface of the plane 		// watch out, you might need to invert the sign of Dparam, depending on what it represents in your plane equation.		end += pCollidedPlane->Normal * (pCollidedPlane->Dparam - end.Dot(pCollidedPlane->Normal));		// test the world again to see if we can find another plane to slide onto		pCollidedPlane = CCollision::collide_with_world(currentPos, end, result);	}	// right, all collisons are done, set the position for the next frame	currentPos = end;}

hehehe... My work is done...

on the box example, it looks like the player''s feet get stuck on the edge. It''s a typical collison problem

yeah, culling back facing polys should help. Also, check if the velocity of the player is going ''towards'' the normal of the polygon. if the player is actually moving away from the poly, skip the polygon.

also, remove that threshold bit in the code.

// make sure we will catch even the tiniest of collisionsfloat threshold = 0.00001f;// currentPos -= velocity * threshold; // maybe not such a good idea

However, you have to be careful with culling the backfacing polygons, if you only do ray-polygon tests, as the start position could be slightly underneath the polygon, but should still be colliding with it, and then the test would fail due to numerical innacuracies.


try this

if (collider->_plane.is_behind(start) ||     collider->_plane.is_moving_towards(end-start)){    // skip this collider}const bool CPlane::is_behind(const CVector3 &p) const{   return (p.Dot(_normal) + _d) < -0.0001f;}const bool CPlane::is_moving_towards(const CVector3 &dir) const{   return (p.Dot(dir) < 0.0001f);}

you can see that I don''t do tests with 0.0f, but instead use very small values. Now, I am not sure if these exact values will help you or not, it depends on your system. But try with very small values, either above or below 0.0f. You have to think about it beforehand, as the sign is quite important. It will either make your player more prone to stumble on polygons, or go through it. Or it might work perfectly

dynamic collisions are very sensitive to thresholds. this is a pain, but it''s unavoidable, due to the numerical innacuracies. Using double precision arithmetic won''t solve the problem totally, it will just make it happening less often.

a way to do it, is to move the ray, not on the result position, but a litle bit before the result position, or a little bit away from the real point of intersection, like

	if (sphere_plane_collision(start, end2, collider->_plane, result))		{			// the intersection distance is shorter thean the previous one found,			// as save it as the potentially closest collision plane			end2 = result + collider->_plane.Normal * 0.001f; // one milimeter above the polygon			pNearestCollidedPlane = collider->_plane;		}

this will make the player jitter very slightly, but it should help for the infinite collision loop.

if it works, great, otherwise, you have to play around with thresholds, and think on where they could be useful.
a way to debug your collision system, is to put rather large thresholds (like replace 0.001f by 0.05f in the code above), see if the player gets stuck, or goes through stuff. It it works fine, reduce the threshold step by step, and find a value where the player doesn''t jump all other the place, nor does get stuck on geometry.

Also, you may want to stop the collision tests if the velocity is close to 0.0f, but it could make stuff go through triangles. Not sure about that one.

hard work, innit?