我把事情简化为立方体/单个立方体与无限质量矩形碰撞，并且代码如下：
问题是，盒子倾向于旋转太多并且卡在一起旋转，如果包含二进制搜索，只需点击并旋转很多。
感谢您的帮助。
/// <summary>
/// Projects an abstract 1D line "perpendicular" to the axis,
/// stretching across the width of the model,
/// measured from that axis.
/// </summary>
/// <param name="Axis"></param>
/// <param name="Min"></param>
/// <param name="Max"></param>
protected virtual void ProjectToAxis(Vector2 Axis, IMotionData motionData, out double Min, out double Max)
{
Double DotP = Axis.Dot(motionData.PositionGS + (this.Vertices[0].Position * this.Model.Scale).Rotate(motionData.RotationGS));
Min = Max = DotP;
for (int t = 1; t < this.Vertices.Count(); ++t)
{
DotP = Axis.Dot(motionData.PositionGS + (this.Vertices[t].Position * this.Model.Scale).Rotate(motionData.RotationGS));
Min = Math.Min(DotP, Min);
Max = Math.Max(DotP, Max);
}
}
/// <summary>
/// Projects two imaginary lines even with each edge,
/// equal to the width of each object while looking at
/// that edge, then checks to see if they intersect.
/// </summary>
/// <param name="B1"></param>
/// <param name="B2"></param>
/// <returns></returns>
public static bool DetectCollision(Body B1, Body B2, Double elapsedSeconds)
{
CollisionData collisionInfo = new CollisionData();
double lowestDistance = double.MaxValue;
double distance;
Vector2 normalB1ToB2 = (B2.MotionHandler.PositionGS - B1.MotionHandler.PositionGS).Normalized;
foreach (Edge edge in B1.Edges)
{
if (edge.Normal.RelativePosition.Dot(normalB1ToB2) >= 0.0)
{
double minA, minB, maxA, maxB;
B1.ProjectToAxis(edge.Normal.RelativePosition, B1.MotionHandler.MotionDataGet, out minA, out maxA);
B2.ProjectToAxis(edge.Normal.RelativePosition, B2.MotionHandler.MotionDataGet, out minB, out maxB);
if (minA < minB)
distance = minB - maxA;
else
distance = minA - maxB;
if (distance > 0.0f)
return false;
else if (Math.Abs(distance) < lowestDistance)
{
lowestDistance = Math.Abs(distance);
collisionInfo.Normal = edge.Normal.RelativePosition;
collisionInfo.Edge = edge;
}
}
}
Vector2 normalB2ToB1 = -normalB1ToB2;
foreach (Edge edge in B2.Edges)
{
if (edge.Normal.RelativePosition.Dot(normalB2ToB1) >= 0.0)
{
double minA, minB, maxA, maxB;
B1.ProjectToAxis(edge.Normal.RelativePosition, B1.MotionHandler.MotionDataGet, out minA, out maxA);
B2.ProjectToAxis(edge.Normal.RelativePosition, B2.MotionHandler.MotionDataGet, out minB, out maxB);
if (minA < minB)
distance = minB - maxA;
else
distance = minA - maxB;
if (distance > 0.0f)
return false;
else if (Math.Abs(distance) < lowestDistance)
{
lowestDistance = Math.Abs(distance);
collisionInfo.Normal = edge.Normal.RelativePosition;
collisionInfo.Edge = edge;
}
}
}
collisionInfo.Depth = lowestDistance;
/* Double lowHighSeconds = elapsedSeconds;
Double highLowSeconds = 0.0;
Double seconds;
IMotionData md1;
IMotionData md2;
bool collision;
do
{
md1 = B1.MotionHandler.MotionDataLastGet.Copy;
md2 = B2.MotionHandler.MotionDataLastGet.Copy;
collision = true;
lowestDistance = Double.MaxValue;
seconds = MathExtensions.MathExt.Lerp(highLowSeconds, lowHighSeconds, 0.5);
B1.MotionHandler.Simulate(seconds, ref md1);
B2.MotionHandler.Simulate(seconds, ref md2);
normalB1ToB2 = (md2.PositionGS - md1.PositionGS).Normalized;
foreach (Edge edge in B1.Edges)
{
if ((edge.Normal.Position * B1.Model.Scale).Rotate(md1.RotationGS).Dot(normalB1ToB2) >= 0.0)
{
double minA, minB, maxA, maxB;
B1.ProjectToAxis((edge.Normal.Position * B1.Model.Scale).Rotate(md1.RotationGS), md1, out minA, out maxA);
B2.ProjectToAxis((edge.Normal.Position * B1.Model.Scale).Rotate(md1.RotationGS), md2, out minB, out maxB);
if (minA < minB)
distance = minB - maxA;
else
distance = minA - maxB;
if (distance > 0.0f)
collision = false;
else if (Math.Abs(distance) < lowestDistance)
{
lowestDistance = Math.Abs(distance);
collisionInfo.Normal = (edge.Normal.Position * B1.Model.Scale).Rotate(md1.RotationGS);
collisionInfo.Edge = edge;
}
}
}
normalB2ToB1 = -normalB1ToB2;
foreach (Edge edge in B2.Edges)
{
if ((edge.Normal.Position * B2.Model.Scale).Rotate(md2.RotationGS).Dot(normalB2ToB1) >= 0.0)
{
double minA, minB, maxA, maxB;
B2.ProjectToAxis((edge.Normal.Position * B2.Model.Scale).Rotate(md2.RotationGS), md2, out minA, out maxA);
B1.ProjectToAxis((edge.Normal.Position * B2.Model.Scale).Rotate(md2.RotationGS), md1, out minB, out maxB);
if (minA < minB)
distance = minB - maxA;
else
distance = minA - maxB;
if (distance > 0.0f)
collision = false;
else if (Math.Abs(distance) < lowestDistance)
{
lowestDistance = Math.Abs(distance);
collisionInfo.Normal = (edge.Normal.Position * B2.Model.Scale).Rotate(md2.RotationGS);
collisionInfo.Edge = edge;
}
}
}
collisionInfo.Depth = lowestDistance;
if (!collision)
{
lowHighSeconds = seconds;
}
else
{
highLowSeconds = seconds;
}
} while (Math.Abs(highLowSeconds - lowHighSeconds) > 0.0001);
B1.MotionHandler.MotionDataSet = md1;
B2.MotionHandler.MotionDataSet = md2; */
// bool flip = false;
if (collisionInfo.Edge.Parent != B2.Model)
{
Body temp = B1;
B1 = B2;
B2 = temp;
}
//This is needed to make sure that the collision normal is pointing at B1
int Sign = Math.Sign(
collisionInfo.Normal.Dot(
B1.MotionHandler.MotionDataGet.PositionGS + (B1.Center * B1.Model.Scale).Rotate(B1.MotionHandler.MotionDataGet.RotationGS) -
B2.MotionHandler.MotionDataGet.PositionGS + (B2.Center * B2.Model.Scale).Rotate(B2.MotionHandler.MotionDataGet.RotationGS)
)
);
//Remember that the line equation is N*( R - R0 ). We choose B2->Center
//as R0; the normal N is given by the collision normal
if (Sign != 1)
collisionInfo.Normal = -collisionInfo.Normal; //Revert the collision normal if it points away from B1
double SmallestD = double.MaxValue; //Initialize the smallest distance to a high value
//Measure the distance of the vertex from the line using the line equation
for (int t = 0; t < B1.Vertices.Count(); ++t)
{
double Distance = collisionInfo.Normal.Dot(B1.Vertices[t].WorldPosition - B2.Center);
// If the measured distance is smaller than the smallest distance reported
// so far, set the smallest distance and the collision vertex
if (Distance < SmallestD)
{
SmallestD = Distance;
collisionInfo.Vertex = B1.Vertices[t];
}
}
if ((Body.CollisionType & CollisionType.Velocity) > 0)
{
Vector2 vab1 = B1.MotionHandler.VelocityGS - B2.MotionHandler.VelocityGS;
Vector2 rap = (B1.MotionHandler.PositionGS - collisionInfo.Normal);
Vector2 rbp = (B2.MotionHandler.PositionGS - collisionInfo.Normal);
Double rap2 = (rap.Cross(collisionInfo.Normal));
Double rbp2 = (rbp.Cross(collisionInfo.Normal));
Vector2 one = (collisionInfo.Vertex.WorldPosition - B1.MotionHandler.PositionGS).GetPerpendicular;
Vector2 two = (collisionInfo.Vertex.WorldPosition - B2.MotionHandler.PositionGS).GetPerpendicular;
Double j = (-(1 + 0.0) * vab1.Dot(collisionInfo.Normal)) /
((collisionInfo.Normal.Dot(collisionInfo.Normal) * (B1.MotionHandler.InverseMassGS + B2.MotionHandler.InverseMassGS)) +
(one.Dot(one) * B1.MotionHandler.InverseInertiaGS) + (two.Dot(two) * B2.MotionHandler.InverseInertiaGS));
B1.MotionHandler.AddImpulse = new Force(
collisionInfo.Normal,
j /* ,
one */
);
B2.MotionHandler.AddImpulse = new Force(
collisionInfo.Normal,
-(j) /* ,
two */
);
NewtonianMotionData data1 = (NewtonianMotionData)B1.MotionHandler.MotionDataGet;
NewtonianMotionData data2 = (NewtonianMotionData)B2.MotionHandler.MotionDataGet;
data1.AngularVelocity += (one.Dot(j * collisionInfo.Normal)) * data1.inverseInertia;
data2.AngularVelocity += (two.Dot(-j * collisionInfo.Normal)) * data2.inverseInertia;
B1.MotionHandler.MotionDataSet = data1;
B2.MotionHandler.MotionDataSet = data2;
}
return true;
}
答案 0 :(得分：7)
你有两个问题。
1）代码有问题。你需要解决这个问题。
2）你不知道如何弄清楚什么是“某事”。
解决第一个问题是关于你解决第二个问题。您需要学习如何调试刚刚编写的程序。
你已经对它进行了测试并得到了一个你认定为无意义的结果。这是一个很好的第一步。现在把它分解得更远。在此域中选择一个简单问题，您可以使用铅笔和纸张自行解决;这样做，然后观察你的算法解决调试器中的相同问题，检查整个过程中的每一步。 聆听安静的唠叨疑惑。当有任何看起来有点偏离或意外的事情时，停止你正在做的事情并调查问题，直到你了解事情是否正常。最终你会找到一个不应该有的东西的步骤，这就是bug的所在。
是的，这很乏味。当您发现错误并修复它时，请暂停并反思导致您首先编写错误的原因，并找出如何不再编写此类错误。
更新：
回复：你最近的评论。
道歉被接受了。现在冷静下来。如果你这样做了，你永远不会找到这个bug。你的大脑不会让你。处于恐慌状态，处于恐慌状态的人类失去了推理能力。这就是防火门向外打开的原因;人们逃离一座燃烧的建筑物，字面意思是不会停下来想“我正在推开这扇门并且它没有打开，也许我应该试着拉”。他们只是更加努力。 我怀疑你在努力推进。
调试需要理性和注意小细节。如果你们都在解决这个问题，那么它就会消失，它会变得更糟。 从那里的人那里拿走它。我们都去过那里。在您自己的程序中导致您无法找到的错误是一件非常令人沮丧的事情。
没有人帮助你的原因是因为......好吧，让我列出必须满足的一系列先决条件，以帮助你提供更多模糊的陈词滥调以及如何集中调试工作的建议： / p>
1）我必须了解有关3D物理模拟的知识。 1992年我对牛顿力学的简单微分方程有了很好的把握，但是我从那时起就没用过它。并且阻尼驱动弹簧的方程与刚体碰撞方程有很大不同。如果我花了几个星期的时间来回顾我的笔记，我可以回到数学，但那是不现实的。你需要一个非常熟悉的人现在使用3D碰撞物理模拟。
2）我必须能够阅读和理解你的代码，代码是数百行，由我以外的其他人编写，以解决我不熟悉的问题。更糟糕的是，该代码的一百行被注释掉了。为什么？它有关系吗？那里有虫子吗？此外，我需要能够阅读和理解代码而无需在调试器中运行它。哎呀，我甚至不能编译那段代码。这取决于我没有的图书馆。
更糟糕的是，其中一个库可能包含错误。据我所知，这个错误在某些代码中是一个错字，它会计算出你没有向我们展示过的正常情况。显示的代码可能是完美的。
3）我需要有空闲时间来解决别人的难题;编写代码并理解物理学的人没有取得进展的问题。
所有这些都是要求;如果其中任何一个缺失，读者无法有效地帮助您。你问的是你不认识的人帮助你在午夜没有手电筒的黑暗仓库里找到一只黑猫 - 一只可能不在那里的猫。你得到的几个人并不奇怪。在阅读了您的问题的74个堆栈溢出用户中，有多少用户符合这三个要求？我遇到了 none 。
如果您需要此网站的帮助，那么发布更简单的问题。将问题缩小到需要较少的物理和模拟算法专业知识的问题，并且只有相关的代码，最好是可以编译和运行的代码。
答案 1 :(得分：2)
这可能不是一个好消息，但我有一些事情可以添加到Eric Lippert的分析和建议中。
您的评论具有误导性。我知道，如果你不熟悉数学和物理学，那么很难准确，但请看看“ProjectToAxis”：
/// Projects an abstract 1D line "perpendicular" to the axis, /// stretching across the width of the model, /// measured from that axis.
如果这听起来很刺耳，请原谅我，但是
相信我，我不是想挑选尼特，只是我想弄清楚这段代码应该做什么，而不好的评论比没有坏。我可以看到这个函数做了什么（假设像“Dot”这样的函数像宣传的那样工作），但是我仍然不知道它是否符合你想做的。
现在我来看看DetectCollision（它不仅仅是检测碰撞）：
/// Projects two imaginary lines even with each edge, /// equal to the width of each object while looking at /// that edge, then checks to see if they intersect.
什么？我所能做的就是忽略这一点并查看代码......其中有一些部分没有多大意义（例如，为什么你要将一个身体投射到身上？ 每一个的边缘？），因此逆向工程将非常困难。
如果我知道您尝试的算法，我可以尝试找到该错误。如果代码有效，我可以尝试推断算法。但如果代码不起作用（我怀疑）你自己并不真正了解算法，那么我们就会陷入困境。
这是一种可行的方法：这个功能太长了，它做了很多，你不知道它正确地做了哪些部分。你应该把它分解成几个函数并单独测试它们。 （由于Eric Lippert所说的原因，我不能自己这样做。）你可以先分成两个函数，一个计算CollisionInfo（让身体保持不变），另一个调整身体的运动（让CollisionInfo保持不变） ）。