• 点乘:两 个向量点乘得到一个标量 ,数 值等于两个 。 b  向量长度桕乘后再乘以二者夹角的佘弦值 。如果两 个 向量a,b均 为单位 向量 ,那 么a.b等 于向量b在 向 量a方 向上的投影的长度

    点乘:两个向量点乘得到一个标量 ,数值等于两个向量长度相乘后再乘以二者夹角的余弦值 。如果两个向量a,b均 为单位 向量 ,那么a.b等于向量b在向量a方向上的投影的长度

    点乘后得到的是一个值

    若结果 == o,则 两向量 互垂直 。
    若结果 < 0  ,则 两向量夹角大于90°。
    若结果 >0  ,则两向量夹角小于 90°。

    叉乘:两 个向量的叉乘得到一个新的向量 ,新向量垂直于原来的两个向量再乘夹角的正弦值 

    叉乘后得到的还是一个向量


    在unity3D里面。两个向量的点乘所得到的是两个向量的余弦值,也就是-1 到1之间,0表示垂直,-1表示相反,1表示相同方向。 两

    个向量的叉乘所得到的是两个向量所组成的面的垂直向量,分两个方向。 简单的说,点乘判断角度,叉乘判断方向。 形象的说当一个

    敌人在你身后的时候,叉乘可以判断你是往左转还是往右转更好的转向敌人,点乘得到你当前的面朝向的方向和你到敌人的方向的所

    成的角度大小

    展开全文
  • 一、点积(又称“数量积”、“内积”)  1、理论知识  在数学中,点积的定义为a·b=|a|·|b|cos 【注:粗体小写字母表示向量,表示向量a,b的夹角,取值范围为[0,π]】。从定义上,我们知道向量的点积得到的是一...

    一、点积(又称“数量积”、“内积”)

        1、理论知识

       在数学中,点积的定义为a·b=|a|·|b|cos<a,b> 【注:粗体小写字母表示向量,<a,b>表示向量a,b的夹角,取值范围为[0,π]】。从定义上,我们知道向量的点积得到的是一个数值。而不是向量(这点大家要注意了!要与叉积进行区别)。另外点积中的夹角<a,b>没有顺序可言,即<a,b>=<b,a>(或a·b=b·a)。所以我们可以通过点积得到两个向量之间的夹角。<a,b>= arccos(a·b / (|a|·|b|))。并且通过点积的正负值,我们可以判断两个向量的方向关系。如果为正,即>0,他们夹角为(0,π/2)。如果为负,夹角为(π/2,π)。

       2、Unity3D中应用

       在Unity中,点积表示为Vector3.Dot(Vector3,Vector3):float——参数为2个向量,返回值为浮点型。

    using UnityEngine;
    using System.Collections;
     
    public class Vector3_Dot : MonoBehaviour {
         
        //向量a
        Vector3 a;
        //向量b
        Vector3 b;
         
        void Start()
        {
            //向量的初始化
            a = new Vector3(3, 0, 0);//x轴方向,长度为3
            b = new Vector3(Mathf.Sqrt(2), Mathf.Sqrt(2), 0);//(根号2,根号2,0)
        }
     
        void OnGUI()
        {
            //点积的返回值
            float c=Vector3.Dot(a,b);
            //向量a,b的夹角,得到的值为弧度,我们将其转换为角度,便于查看!
            float angle=Mathf.Acos( Vector3.Dot(a.normalized,b.normalized))*Mathf.Rad2Deg;
            GUILayout.Label("向量a,b的点积为:" + c);
            GUILayout.Label("向量a,b的夹角为:" + angle);
        }
         
    }


    a.normalized表示该方向的单位向量,即方向与向量a相同,长度为1的向量。Mathf.Acos()即数学中的arccos()函数。Mathf.Rad2Deg表示将弧度转化为角度。

    结果如下图:


    二、叉积(又称“向量积”、“外积”)

       1、理论知识

       数学上的定义:c=axb【注:粗体小写字母表示向量】其中a,b,c均为向量。即两个向量的叉积得到的还是向量!

       性质1:c⊥a,c⊥b,即向量c垂直与向量a,b所在的平面。

       性质2:模长|c|=|a||b|sin<a,b>

       性质3:满足右手法则。从这点我们有axb ≠ bxa,而axb = - bxa。所以我们可以使用叉积的正负值来判断向量a,b的相对位置,即向量b是处于向量a的顺时针方向还是逆时针方向。

       2、Unity中应用

       在Unity中,叉积表示为Vector3.Cross(Vector3,Vector3):Vector3——参数为2个向量,返回值也为向量。

    using UnityEngine;
    using System.Collections;
     
    public class Vector3_Cross : MonoBehaviour {
     
        //向量a
        Vector3 a;
        //向量b
        Vector3 b;
     
        void Start()
        {
            //向量的初始化
            a = new Vector3(3, 0, 0);//x轴方向,长度为3
            b = new Vector3(0, 4, 0);//y轴方向,长度为4
        }
     
        void OnGUI()
        {
            //叉积的返回值
            Vector3 c = Vector3.Cross(a, b);
            Vector3 d = Vector3.Cross(b, a);
            //向量a,b的夹角,得到的值为弧度,我们将其转换为角度,便于查看!
            float angle = Mathf.Asin(Vector3.Distance(Vector3.zero, Vector3.Cross(a.normalized, b.normalized))) * Mathf.Rad2Deg;
            GUILayout.Label("向量axb为:" + c);
            GUILayout.Label("向量bxa为:" + d);
            GUILayout.Label("向量a,b的夹角为:" + angle);
        }
    }


    Vector3.Distance()用于计算2个Vector3的距离,在这里我们可以得到叉积向量的模长。

    结果如下图:


    展开全文
  • 【参考原文】Unity3D点乘和差乘  在Unity3D中,Vector3.Dot表示求两个向量的点积;Vector3.Cross表示求两个向量的叉积。    点积计算的结果为数值,而叉积计算的结果为向量。两者要注意区别开来。    简单...

    【参考原文】Unity3D之Vector3.Dot和Vector3.Cross的使用
    【参考原文】Unity3D之点乘和差乘
      在Unity3D中,Vector3.Dot表示求两个向量的点积;Vector3.Cross表示求两个向量的叉积。
      
      点积计算的结果为数值,而叉积计算的结果为向量。两者要注意区别开来。
      
      简单的说,点乘判断角度,叉乘判断方向。

      形象的说当一个敌人在你身后的时候,叉乘可以判断你是往左转还是往右转更好的转向敌人,点乘得到你当前的面朝向的方向和你到敌人的方向的所成的角度大小。

    1.点积

    a·b=|a|·|b|cos<a,b>

    • |a|和|b|表示向量的模
    • <a,b>表示两个向量的夹角。<a,b>和<b,a> 夹角是不分顺序的。
    • 通过点积可以计算两个向量的夹角的。

    如果两个向量a,b均 为单位 向量 ,那么a.b等于向量b在向量a方向上的投影的长度

    应用

      通过点积的计算我们可以简单粗略的判断当前物体是否朝向另外一个物体: 只需要计算当前物体的transform.forward向量与 (otherObj.transform.position – transform.position)的点积即可。
    - 若结果 == 0,则两向量互垂直 。
    - 若结果 > 0 ,则两向量夹角小于90°,当前物体面对
    - 若结果 < 0 ,则两向量夹角大于 90°,当前物体背对

    2.叉积

    c =a x b

    • 其中a,b,c均为向量。即两个向量的叉积得到的还是向量!
    • 性质1:c⊥a,c⊥b,即向量c垂直与向量a,b所在的平面。
    • 性质2:模长|c|=|a||b|sin<a,b>
    • 性质3:满足右手法则。从这点我们有axb ≠ bxa,而axb = – bxa。所以我们可以使用叉积的正负值来判断向量a,b的相对位置,即向量b是处于向量a的顺时针方向还是逆时针方向。

    求两向量夹角

    using UnityEngine;  
    using System.Collections;  
    
    public class MainScript : MonoBehaviour  
    {  
            //向量a  
            private Vector3 a;  
            //向量b  
            private Vector3 b;  
    
            void Start ()  
            {  
                    //向量的初始化  
                    a = new Vector3 (1, 2, 1);  
                    b = new Vector3 (5, 6, 0);  
            }  
    
            void OnGUI ()  
            {  
                    //点积的返回值  
                    float c = Vector3.Dot (a, b);  
                    //向量a,b的夹角,得到的值为弧度,我们将其转换为角度,便于查看!  
                    float angle = Mathf.Acos (Vector3.Dot (a.normalized, b.normalized)) * Mathf.Rad2Deg;  
                    GUILayout.Label ("向量a,b的点积为:" + c);  
                    GUILayout.Label ("向量a,b的夹角为:" + angle);  
    
    
                    //叉积的返回值  
                    Vector3 e = Vector3.Cross (a, b);  
                    Vector3 d = Vector3.Cross (b, a);  
                    //向量a,b的夹角,得到的值为弧度,我们将其转换为角度,便于查看!  
                    angle = Mathf.Asin (Vector3.Distance (Vector3.zero, Vector3.Cross (a.normalized, b.normalized))) * Mathf.Rad2Deg;  
                    GUILayout.Label ("向量axb为:" + e);  
                    GUILayout.Label ("向量bxa为:" + d);  
                    GUILayout.Label ("向量a,b的夹角为:" + angle);  
            }  
    }  

    上面的示例中,我们定义了两个向量a和b。分别求出了他们的点积和叉积,并通过点积和叉积来反过来计算他们的夹角。
    这里要说明的是:
    1.a.normalized 和 b.normalized 表示的是两个向量的单位向量, 因为在公式里,有向量和模的除法,得出来的结果就是单位向量(单位向量模为1),所以我们这里和后面都直接用单位向量来计算,省去不少麻烦。

    2.Mathf.Rad2Deg表示的是 单位弧度的度数。也就是2π/360

    3.通过叉积计算度数是通过公式|c|=|a||b|sin<a,b>来逆向求值。|c| 其实就是叉积的模,换句话说,也代表着Vector3.Distance (Vector3.zero, Vector3.Cross (a.normalized, b.normalized))的值。
    结果图如下:
    这里写图片描述

    点乘与叉乘项目中的应用

    项目需求:
    1 通过点乘计算物体B在物体A的前方还是后方
    2 通过叉乘,计算物体A转向物体B时,最小角的旋转方向

    实现过程:
    首先计算出物体A的前方朝向向量v_Bz=B.transform.forward,然后计算物体B相对于物体A的位置向量 v_AB = A.position - B.position;

    通过计算v_Bz与v_AB向量点乘结果的正负,判断物体B在物体A的前后
    如果物体B在物体A前方, Vector3.Dot(v_Bz,v_AB)大于0
    如果物体B在物体A后方, Vector3.Dot(v_Bz,v_AB)小于0

    通过计算v_Bz与v_AB向量叉乘的结果,判断旋转方向
    如果逆时针旋转,v_C = Vector3.Cross(v_Bz, v_AB)为沿y轴负方向
    如果顺时针旋转,v_C = Vector3.Cross(v_Bz, v_AB)为沿y轴正方向

    using UnityEngine;
    using System.Collections;
    
    public class Vector3_Dot : MonoBehaviour {
    
        public Transform A, B;
        Vector3 v_Bz, v_AB, v_A,v_B,v_C;
        string str = "";
    
    
    
        // Use this for initialization
        void Start()
        {
    
        }
    
        // Update is called once per frame
        void Update()
        {
    
    
            //点乘
            v_Bz = B.transform.forward;//B.transform.TransformDirection(Vector3.forward);
            v_AB = A.position - B.position;
            float f = Vector3.Dot(v_Bz,v_AB);
            if (f>0)
            {
                str = "A在B自身座标系的前方";
            }
            else if (f<0)
            {
                str = "A在B自身座标系的后方";
    
            }
            else
            {
                str = "A在B自身座标系的左前方或右方";
            }
    
            //差乘
            v_A = A.position;
            v_B = B.position;
            v_C = Vector3.Cross(v_Bz, v_AB);
           // A.Rotate(0,0,0);
    
        }
    
        void OnGUI()
        {
            GUI.Label(new Rect(10,10,200,60),str);
    
        }
    
    
    
        void OnDrawGizmos()
        {
            //差乘绘制相关线
            Gizmos.color = Color.blue;
            Gizmos.DrawLine(-v_C,Vector3.zero);
    
    
    
            //点乘绘制相关线
            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(Vector3.zero,A.position);
    
            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(Vector3.zero,B.position);
    
            Gizmos.color = Color.red;
            Gizmos.DrawLine(A.position, B.position);
    
            Gizmos.color = Color.red;
            Gizmos.DrawLine(Vector3.zero,v_AB);
    
            Gizmos.color = Color.green;
           // Gizmos.DrawLine(A.transform.position, Vector3.left);
    
        }
    }

    这里写图片描述

    总结

    1.判断目标在自己的前后方位可以使用下面的方法:

    Vector3.Dot(transform.forward, target.position-transform.position)

    返回值为正时,目标在自己的前方,反之在自己的后方

    2.判断目标在机子的左右方位可以使用下面的方法:

    Vector3.Cross(transform.forward, target.position-transform.position).y

    返回值为正时,目标在自己的右方,反之在自己的左方

    展开全文
  • Unity叉乘点乘测试

    2020-05-28 00:12:27
    为了让自己对叉乘和点乘有个直观的理解 所以做了这个测试程序 能查看两个小球不同夹角下的叉乘点乘的结果 方便理解 github测试代码

    为了让自己对叉乘和点乘有个直观的理解 所以做了这个测试程序 能查看两个小球不同夹角下的叉乘点乘的结果 方便理解

    github上的测试代码

     

    展开全文
  • PS:本系列笔记将会记录我此次在北京学习Unity开发的总体过程,方便后期写总结,笔记为日更。 笔记内容均为 自己理解,不保证每个都对 点乘求角度,叉乘求方向 比如敌人再附近,点乘可以求出玩家面朝方向和敌人方向的...

    PS:本系列笔记将会记录我此次在北京学习Unity开发的总体过程,方便后期写总结,笔记为日更。
    笔记内容均为 自己理解,不保证每个都对

    点乘求角度,叉乘求方向
    比如敌人再附近,点乘可以求出玩家面朝方向和敌人方向的夹角,叉乘可以得出左转还是右转更好的转向敌人

    Part 1 点乘:

    数学上的 点乘为 a * b = |a| * |b| * cos(Θ)
    Unity中的点乘也是如此 点乘结果为 float 是投影长度
    点乘的主要作用就是,点乘求角度。 Θ = Arcos( a * b / |a| * |b|)
    代码实现:

            float tmpNormalized = Vector3.Dot(attacked.right.normalized, tmpDistance.normalized);       //计算出在攻击方向的单位向量上的投影
    
            float tmpRadian = Mathf.Acos(tmpNormalized);     //计算出弧度
    
            float tmpAngle = Mathf.Rad2Deg * tmpRadian;		//弧度转换为角度
    

    点乘的方法是

     Vector3.Dot(向量A,向量B);	  得到的结果是数  即 B在A上的投影长度
    

    例如:

    tmpDistanceX = Vector3.Dot(attacker.right, tmpDis);		//即tmpDis 在 attacker.right向量上的投影长度
    

    点乘的简单应用A:设置矩形体区域

        /// <summary>
        /// 以攻击点为中心,长为 2 * distance 宽为 2 * half 高为2 * height的矩形体范围
        /// </summary>
        /// <param name="attacker">生成范围的中心点的位置</param>
        /// <param name="attacked">目标物体的位置</param>
        /// <param name="half">中心点到两侧的宽度,实际宽度为2倍长度</param>
        /// <param name="distance">中心点到最远攻击点的距离</param>
        /// <param name="height">中心点到最高的距离</param>
        /// <returns></returns>
        private bool RectAttack(Transform attacker, Transform attacked, float half, float distance, float height)     //生成一个矩形体范围的碰撞区域
        {
            Vector3 tmpDis = attacked.position - attacker.position;     //算出攻击者和被攻击者之间的向量差
    
            float tmpDistanceX, tmpDistanceY, tmpDistanceZ;
    
            tmpDistanceX = Vector3.Dot(attacker.right, tmpDis);        //算出向量差在 攻击方向上的投影,设攻击方向为  right
            Debug.Log("tmpDistance.X = " + tmpDistanceX);
    
            //float tmpDistance = Vector3.Distance(attacker.position, attacked.position);      //实际距离
            //Debug.Log("tmpDistance = " + tmpDistance);          
    
            if (tmpDistanceX >= 0 && tmpDistanceX <= distance)     //判断投影是在 攻击方向正面,且在攻击范围内
                //排除了目标在攻击点背后的情况
            {
    
                tmpDistanceZ = Mathf.Abs(Vector3.Dot(attacker.forward, tmpDis));              //计算向量差在 攻击范围横轴上的距离
    
                tmpDistanceY = Mathf.Abs(Vector3.Dot(attacker.up, tmpDis));             //计算向量差在 攻击范围横轴上的距离
    
    
                if (tmpDistanceZ <= half && tmpDistanceY <= height)            //在范围内则进行攻击
                {
                    Debug.Log("Attacked!!!");
                    return true;
                }
            }
    
            return true;
        }
    

    点乘的简单应用B:设置扇形体区域

    
        /// <summary>
        /// 以攻击点为中心,到任一点夹角为45°,且长度为radius的扇形体区域
        /// 扇形所指的为 以攻击点为固定点,长度为radius,角度为 2 * angle的覆盖区域
        /// </summary>
        /// <param name="attacker">攻击者的位置</param>
        /// <param name="attacked">被攻击者的位置</param>
        /// <param name="angle">攻击点到其中一侧的夹角,即整个扇形角度为 2 * angle</param>
        /// <param name="radius"></param>
        /// <returns></returns>
        private bool UmbrallaAttack(Transform attacker, Transform attacked, float angle, float radius)      //生成一个扇形体范围的碰撞区域
        {
            Vector3 tmpDistance = attacked.position - attacker.position;        //算出攻击者和被攻击者之间的向量差
    
            //取值范围 [-1, 1]
            float tmpNormalized = Vector3.Dot(attacked.right.normalized, tmpDistance.normalized);       //计算出在攻击方向的单位向量上的投影
    
            float tmpRadian = Mathf.Acos(tmpNormalized);     //计算出弧度
    
            float tmpAngle = Mathf.Rad2Deg * tmpRadian;
    
    
            float tmpDis = tmpDistance.magnitude;           //已知向量,求tmpDistance的距离长度
            //float tmpDis2 = Vector3.Distance(attacker.position, attacked.position);     //求两点间的距离长度
    
            //Debug.Log("tmpAngle == " + tmpAngle + "tmpDis == " + tmpDis + "tmpDis2 == " + tmpDis2);
    
            if(tmpAngle <= angle && tmpDis <= radius)
            {
                Debug.Log("Attack!!!");
                return true;
            }
    
    
            return false;
        }
    

    Part 2 叉乘:

    数学上的叉乘 使用右手定则 确认 结果向量方向
    Unity中的叉乘 使用左手定则 确认结果向量方向
    叉乘方法

     Vector3.Cross(tmpA, tmpB)		叉乘结果是一个向量
    

    **叉乘的主要应用是:**求方向
    在同一平面内, 结果 > 0 表示 B在A的逆时针方向, 结果 <0 表示B在A的顺式针方向, 结果 = 0表示B与A同向

    左手定则:
    Vector3.Cross(tmpA, tmpB) tmpA为大拇指,食指为tmpB, 其余三指自然弯曲90°即为叉乘结果
    在这里插入图片描述
    叉乘简单应用:判断方向

        private void CrossTest(Vector3 tmpA, Vector3 tmpB)
        {
            Vector3 result = Vector3.Cross(tmpA, tmpB);
            if(result.y> 0)
            {
                Debug.Log("tmpB在tmpA的顺时针方向");
            }
            if (result.y == 0)
            {
                Debug.Log("tmpB在tmpA同向");
                
            }
            if (result.y < 0)
            {
                Debug.Log("tmpB在tmpA的逆时针方向");
            }
    
        }
    
    
    
        void Update()
        {
            Vector3 tmpA = attacked.position - transform.position;
            Vector3 tmpB = newAttacked.position - transform.position;
            CrossTest(tmpB, tmpA);
        }
    

    在这里插入图片描述
    测试结果:
    在这里插入图片描述

    Part 3 点乘和叉乘的综合应用:

    点乘求出相差角度,叉乘求出转向
    让AI朝玩家方向自动移动,转向

        void Update()
        {
            Vector3 tmpVector = Player.transform.position - transform.position;
    
            float tmpDistance = tmpVector.magnitude;        //计算AI到Player之间的距离
    
            //Debug.Log("Distance == " + tmpDistance);
            if (tmpDistance <= 7)
            {
                TimeCount += 0.1f;
                if (TimeCount >= 0)
                {
                    Debug.Log("Attack!!!");
                    BulletParent.GetComponent<BulletGen>().GenBullet();     //调用子弹实例化脚本方法
                    TimeCount = 0;
                }
    
                //transform.LookAt(Player);
            }
            else
            {
                Vector3 tmpCross = Vector3.Cross(transform.forward, tmpVector);     //叉乘计算书 玩家在AI的哪一侧
    
                if(tmpCross.y >= 0)
                {
                    transform.Rotate(Vector3.up, 0.5f);
                }
    
                if (tmpCross.y < 0)
                {
                    transform.Rotate(Vector3.up, -0.5f);
                }
    
                transform.Translate(Vector3.forward* 0.02f, Space.Self);
            }
        }
    }
    

    根据以前内容,结合今天所学的点乘叉乘,可制作简易坦克大战Demo
    在这里插入图片描述

    展开全文
  • unity3D里面。两个向量的点乘所得到的是两个向量的余弦值,也就是-1 到1之间,0表示垂直,-1表示相反,1表示相同方向。 两个向量的叉乘所得到的是两个向量所组成的面的垂直向量,分两个方向。   简单的...
  • 向量的点乘 用来求向量之间的夹角或者用来判断向量是否在同一方向、以及在某一方向的投影。 判断如下: a·b>0 方向基本相同,夹角在0°到90°之间 ...向量的叉乘Unity中的作用是用来求向量所在平面的法向量。
  • 点乘:两个向量点乘得到一个标量 ,数值等于两个向量长度相乘后再乘以二者夹角的余弦值 。如果两个向量a,b均 为单位 向量 ,那么a.b等于向量b在向量a方向上的投影的长度 点乘后得到的是一个值 若结果 == o,则 ...
  • 术语点乘来自A·B中的点号(点乘· 叉乘* )向量点乘对应分量乘机的和,它结果是一个标量它的公式  A·B=Ax*Bx+AyBy+AzBz 例如(3,1,-1)·(7,2,1)=3*7+1*2+(-1)*1=22 看下图就好。感受手写比打字方便多了呀!!!! ...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 点乘: 意义:可以判断目标物体是否在我的前方;    Vector3.Dot(transform.forward, Target.position-transform.position)大于零表示在我前面,小于零表示在我后面 等于零表示在我正左边或者正右边。   ...
  • Unity-点乘,叉乘

    2020-05-29 21:08:47
    Unity-点乘,叉乘
  • 在看了很多文章和书籍直后发现Unity中的数学知识是很重要的,想要做到游戏的高真实度和高流畅度,数学是必不可少的,今天就来记录一下基础的3D数学在Unity中开发时的运用,若文章中所写有不足,欢迎指出留言,互相...
  • 可以用 点乘 来判断物体是在人物的前方,还是后方, 用 叉乘 来判断是在人物的 左手边,还是右手边。
  • Unity 3D 点乘叉乘

    2016-07-07 17:33:03
    点乘:两个向量点乘得到一个标量 ,数值等于两个向量长度相乘后再乘以二者夹角的余弦值 。如果两个向量a,b均 为单位 向量 ,那么a.b等于向量b在向量a方向上的投影的长度 点乘后得到的是一个值 若结果 == o,则 两向量...
  • Unity3D点乘和差乘

    2019-08-01 04:24:40
    一、向量 1、向量的数学定义 向量就是一个数字列表,对于程序员来说一个向量就是一个数组。向量的维度就是向量包含的“数”的数目,向量可以有任意正数维,标量可以被认为是一维向量。书写向量时,用方括号将一列...
  • Unity 点乘(Dot)、叉乘(Cross)判断移动方向、朝向等向量问题 项目中常会用到物体移动,追踪,判断两物体移动方向是否相同,两物体移动方向夹角,以及物体 A 朝 物体 B 顺时针方向还是逆时针方向移动。物体 ...
  • 一、点积(又称“数量积”、“内积”)  1、理论知识 在数学中,点积的定义为a·b=|a|·|b|cosa,b> 【注:粗体小写字母表示向量,a,b>表示向量a,b的夹角,取值范围为[0,π]】。从定义上,我们知道向量的点积...
1 2 3 4 5 ... 20
收藏数 583
精华内容 233