如何基于Helix Toolkit实现3D链条从起点到终点定向绘制？

核心思路是通过向量变换+旋转矩阵将原本沿Y轴排列的链节转换到起点到终点的方向上，同时按链节数量均匀分布到终点位置。

关键修改步骤 #

1. 计算链节步长与总长度

   • 先算出单个链节的总长度（即你代码中的translate），再根据起点到终点的距离和链节数量，调整每个链节的移动步长，确保最后一个链节刚好抵达终点。
   • 计算起点到终点的向量totalVector = endVector - startVector，单位化后得到目标方向direction。

2. 构建旋转矩阵

   • 链节原本沿本地Y轴延伸，需要创建旋转矩阵将本地Y轴对齐到目标direction向量，让所有链节的顶点都旋转到正确方向。
   • 通过正交基向量（右、上、方向）构建旋转矩阵，避免方向与坐标轴重合的异常情况。

3. 调整链节位置与旋转

   • 每个链节的起始位置 = 起点 + 步长向量 × 链节索引
   • 先在本地坐标处理交替链节的旋转，再用全局旋转矩阵转换到目标方向，最后平移到对应位置。

修改后的完整代码 #

using HelixToolkit.SharpDX.Core;
using HelixToolkit.Wpf.SharpDX;
using SharpDX;

namespace RapiD.Geometry.Models
{
    public partial class ChainLink3D : GeometryBase3D 
    {
        [ObservableProperty]
        float radius;
        [ObservableProperty]
        float width;
        [ObservableProperty]
        float diameter;
        [ObservableProperty]
        float length;
        [ObservableProperty]
        int copies;
        [ObservableProperty]
        ObservableCollection<Element3D> elements;

        public ChainLink3D(float diameter, float width, float length, int copies)
        {
            this.width = width;
            this.length = length;
            this.diameter = diameter;
            this.copies = copies;
            this.elements = new ObservableCollection<Element3D>();   

            OriginalMaterial = PhongMaterials.Chrome;
            DrawChainLink();
        }

        public void DrawChainLink()
        {
            MeshBuilder meshBuilder = new MeshBuilder();
            float radius = (width - diameter) / 2;
            float singleLinkLength = length + (radius * 2) - diameter;
            float yoffset = 0;
            int segments = 10;
            float interval = 180 / segments;
            int numOfCopies = copies;

            Vector3 startVector = new Vector3(-300, 200f, 0);
            Vector3 endVector = new Vector3(300, 500, 0);
            Vector3 totalVector = endVector - startVector;
            float totalDistance = totalVector.Length();
            Vector3 direction = Vector3.Normalize(totalVector);

            // 计算每个链节的步长：确保最后一个链节刚好到终点
            float stepDistance = numOfCopies > 1 ? totalDistance / (numOfCopies - 1) : 0;
            Vector3 stepVector = direction * stepDistance;

            // 构建旋转矩阵：将本地Y轴对齐到目标方向
            Vector3 localUp = Vector3.Up;
            Vector3 right = Vector3.Cross(localUp, direction);
            if (right.LengthSquared() < 0.0001f) // 处理方向与Up重合的特殊情况
                right = Vector3.Right;
            right = Vector3.Normalize(right);
            Vector3 newUp = Vector3.Cross(direction, right);
            Matrix rotationMatrix = Matrix.FromBasis(right, newUp, direction);

            // 循环绘制链节
            for (int j = 0; j < numOfCopies; j++)
            {
                List<Vector3> single_chain_link = new List<Vector3>();
                // 当前链节的世界位置
                Vector3 linkWorldPos = startVector + stepVector * j;

                for (float i = 0; i <= 360; i += interval)
                {
                    yoffset = i > 180 ? -length : 0;
                    float a = i * MathF.PI / 180;
                    float x = radius * MathF.Cos(a);
                    float y = radius * MathF.Sin(a) + yoffset;

                    Vector3 localVec = new Vector3(x, y, 0);
                    
                    // 处理交替链节的旋转
                    if (j % 2 == 1)                    
                        localVec = new Vector3(0, y, x);

                    // 转换到世界坐标：先旋转，再平移
                    Vector3 worldVec = Vector3.Transform(localVec, rotationMatrix) + linkWorldPos;
                    single_chain_link.Add(worldVec);
                }

                // 绘制参考球
                meshBuilder.AddSphere(startVector, 5, 10, 10);
                meshBuilder.AddSphere(endVector, 5, 10, 10);
            
                meshBuilder.AddTube(single_chain_link, diameter, 10, true);
                // 计算链节首尾的世界坐标（用于箭头和元素记录）
                Vector3 localStart = new Vector3(0, radius - (diameter / 2), 0);
                Vector3 localEnd = new Vector3(0, -length - radius + (diameter / 2), 0);
                if (j % 2 == 1)
                {
                    localStart = new Vector3(0, localStart.Y, localStart.X);
                    localEnd = new Vector3(0, localEnd.Y, localEnd.X);
                }
                Vector3 worldStart = Vector3.Transform(localStart, rotationMatrix) + linkWorldPos;
                Vector3 worldEnd = Vector3.Transform(localEnd, rotationMatrix) + linkWorldPos;
                meshBuilder.AddArrow(worldStart, worldEnd, 2, 10);
                elements.Add(new Element3D(worldStart, worldEnd));

                MeshGeometry = meshBuilder.ToMeshGeometry3D();
            }
        }
    }
}

关键细节说明 #

• 旋转矩阵：通过正交基向量构建的矩阵能保证链节完全贴合目标方向，同时保持自身姿态不扭曲。
• 步长计算：totalDistance / (copies - 1)的逻辑确保链节均匀分布在起点到终点的线段上，不会出现超出或未达终点的情况。
• 交替链节处理：先在本地坐标完成旋转，再应用全局变换，保证交替链节在目标方向上依然保持交叉的正确形态。

内容的提问来源于stack exchange，提问作者jaapie