矩阵对象之间的距离，相对于父母定位，使用XNA？

  • Z时代
  • 2024-01-10
  • 分类：问答

我想了解如何测量两个3D对象之间的距离，我们称它们为父对象和子对象。将父母视为汽车的车身，将孩子视为汽车的车轮。矩阵对象之间的距离，相对于父母定位，使用XNA？

我明白如何让基于在世界空间中的物体位置的不同，但我想获得的测量依据的父母相对对象空间上的差异。

E.g如果父面向东和孩子是2X，从父，在相对意义上测量3Y。这样，如果父母旋转了60度，则孩子的相对位置在对象空间中保持在2x，3y的距离。就像在世界空间意义上那样，孩子将测量作为一个Vector3来进行测量会有很大的不同。

基本上我只想一个可预测的方式来获得的区别使得儿童对象，它是对专利权的能够始终保持正确的父对象。

这是父组件，此更新正在运行的每帧：

[Serializable] 
    public class Component_Parent : BaseComponentAutoSerialization<ISceneEntity> 
    { 
     public override void OnUpdate(GameTime gameTime) 
     { 
      PassThrough.ParentMatrix = ParentObject.World; 
      PassThrough.ParentTranslation = ParentObject.World.Translation; 
     } 
    }

接下来的这个部分是子组件：

[Serializable] 
    public class Component_Child : BaseComponentAutoSerialization<ISceneEntity> 
    { 
     Vector3 _parentOffset; 
     Quaternion _parentQuaternionOffset; 
     public override void OnUpdate(GameTime gameTime) 
     { 
      // Get a sceneobject from the ParentObject 
      SceneObject sceneobject = (SceneObject)ParentObject; 
      // This relies on the position never being at 0,0,0 for setup, so please don't do that 
      // or change it with more look ups so that you don't need to rely on a Zero Vector3 :-) 
      if (PassThrough.GroupSetupMode || _parentOffset == Vector3.Zero) 
      { 
       if (PassThrough.ParentTranslation != Vector3.Zero) 
       { 
        _parentOffset = sceneobject.World.Translation - PassThrough.ParentTranslation; 
        // Decompose World Matrix (Parent) 
        Quaternion parentQ = new Quaternion(); 
        Vector3 parentSpot = new Vector3(); 
        Vector3 parentScale = new Vector3(); 
        PassThrough.ParentMatrix.Decompose(out parentScale, out parentQ, out parentSpot); 
        Matrix identity = Matrix.Identity; 
        // Decompose Identity Matrix (Parent) 
        Quaternion identityQ = new Quaternion(); 
        Vector3 identitySpot = new Vector3(); 
        Vector3 identityScale = new Vector3(); 
        identity.Decompose(out identityScale, out identityQ, out identitySpot); 
        _parentQuaternionOffset = identityQ - parentQ; 
       } 
      } 
      else 
      { 
       if (_parentOffset != Vector3.Zero) 
       { 
        // Decompose World Matrix (Child) 
        Quaternion rotationQ = new Quaternion(); 
        Vector3 spot = new Vector3(); 
        Vector3 scale = new Vector3(); 
        sceneobject.World.Decompose(out scale, out rotationQ, out spot); 
        // Decompose World Matrix (Parent) 
        Quaternion parentQ = new Quaternion(); 
        Vector3 parentSpot = new Vector3(); 
        Vector3 parentScale = new Vector3(); 
        PassThrough.ParentMatrix.Decompose(out parentScale, out parentQ, out parentSpot); 
        Matrix location = Matrix.CreateTranslation(PassThrough.ParentTranslation); 
        Matrix rotation = Matrix.CreateFromQuaternion(parentQ); 
        Matrix rotation2 = Matrix.CreateFromQuaternion(_parentQuaternionOffset); 
        Matrix newWorld = rotation * location; 
        Vector3 testTranslation = newWorld.Translation + ((newWorld.Left * _parentOffset.X) + (newWorld.Up * _parentOffset.Y) + (newWorld.Forward * _parentOffset.Z)); 
        Matrix scaleM = Matrix.CreateScale(scale); 
        //sceneobject.World = scaleM * (rotation * (Matrix.CreateTranslation(testTranslation))); 
        sceneobject.World = (Matrix.CreateTranslation(testTranslation)); 
       } 
      } 
     } 
    }

我认为这事做随时追踪一个偏移旋转，从单位矩阵和我已经开始尝试添加一些代码来达到这个效果，但是现在还不确定接下来会发生什么。

附加：

如果我有面向世界空间的方向父对象所有的工作，如果它面向不同的方向，然后这是一个问题，孩子似乎被当它们是同量旋转分组在一起。

我已经上传了一个演示视频，试图解释：

http://www.youtube.com/watch?v=BzAKW4WBWYs

我也贴为组件的完整代码，静态穿过场面实体。

http://pastebin.com/5hEmiVx9

由于

回答：

问题是我试图使用世界空间的偏移量的方式。 感谢从EFnet上#XNA闪现，此代码完美工作：

[Serializable] 
    public class Component_Child_fromxna : BaseComponentAutoSerialization<ISceneEntity> 
    { 
     Vector3 _parentOffset; 
     Matrix _ParentMatrixOffset; 
     public override void OnUpdate(GameTime gameTime) 
     { 
      // Get a sceneobject from the ParentObject 
      SceneObject sceneObject = (SceneObject)ParentObject; 
      // This relies on the position never being at 0,0,0 for setup, so please don't do that 
      // or change it with more look ups so that you don't need to rely on a Zero Vector3 :-) 
      if (PassThrough.GroupSetupMode || _parentOffset == Vector3.Zero) 
      { 
       if (PassThrough.ParentTranslation != Vector3.Zero) 
       { 
        // The old offset - This is just in world space though... 
        _parentOffset = sceneObject.World.Translation - PassThrough.ParentTranslation; 
        // Get the distance between the child and the parent which we keep as the offset 
        // Inversing the ParentMatrix and multiplying it by the childs matrix gives an offset 
        // The offset is stored as a relative xyz, based on the parents object space 
        _ParentMatrixOffset = sceneObject.World * Matrix.Invert(PassThrough.ParentMatrix); 
       } 
      } 
      else 
      { 
       if (_parentOffset != Vector3.Zero) 
       { 
        //Matrix pLocation = Matrix.CreateTranslation(_parentOffset); 
        //sceneObject.World = Matrix.Multiply(pLocation, PassThrough.ParentMatrix); 
        sceneObject.World = Matrix.Multiply(_ParentMatrixOffset, PassThrough.ParentMatrix); 
       } 
      } 
     } 
    }

回答：

两个对象之间的距离不任一取向的函数。

，你基本上要的是子对象的父对象的方位线的距离。假设你有一个全球笛卡尔坐标系，这可以简单地计算为h = sqrt（x^2 + y^2）* sin（Theta），x和y是孩子相对于父母的相对坐标，Theta父方向从x轴测量。

但仍然问题是有点混乱给我。如果你只想确保孩子在父母的右边，为什么不简单地检查相对的x？如果它是正面的，它是在右边，如果它是负面的，它在左边？

回答：

在汽车轮子思考。我希望右轮相对于汽车车身始终位于相同的位置 。

这听起来像你希望能够找到汽车的任何给定的方向或位置的车轮的位置。一个建立在XNA必须帮助的方法是Model.CopyAbsoluteBoneTransformsTo（Matrix []）;但是，您的代码看起来像要手动处理父子关系。所以这里是一种不使用内置方法的方法。它假定您在加载时有偏移量信息：

在游戏循环开始之前（比如说在LoadContent方法中），在加载车轮&并假设它们载入正确位置之后，您可以创建偏移量矢量（_parentOffset）

Vector3 _parentOffset = wheel.meshes[?].ParentBone.Transform.Translation - car.meshes[?].ParentBone.Transform.Translation;//where ? is the mesh index of the mesh you are setting up.

保存该矢量，不要修改它。

后，车的矩阵一直旋转和或位置偏移后，设置车轮的矩阵是这样的：

Matrix wheelMatrix = carMatrix; 
wheelMatrix.Translation += (wheelMatrix.Right * _parentOffset.X) + 
          (wheelMatrix.Up * _parentOffset.Y) + 
          (wheelMatrix.Backward * _parentOffset.Z);

这使得车轮矩阵将继承与汽车的旋转和平移的信息，但会无论车辆的方向/位置如何，都可以适当地移动车轮的位置。

以上是 矩阵对象之间的距离，相对于父母定位，使用XNA？ 的全部内容， 来源链接： utcz.com/qa/259450.html

回到顶部