Unity之Vector3D：重现Vector3

最新推荐文章于 2024-08-26 07:58:37 发布
最新推荐文章于 2024-08-26 07:58:37 发布
阅读量3.6k 收藏 6
点赞数 1
分类专栏： Unity 文章标签： unity Vector3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26999509/article/details/53608268
版权

博客迁移

个人博客站点，欢迎访问，www.jiingfengji.tech

正文

直接上代码

using System;
using System.Text;
using UnityEngine;

public class Vector3D
{

    public static Vector3D back
    {
        get
        {
            return new Vector3D(0, 0, -1);
        }
    }

    public static Vector3D down
    {
        get
        {
            return new Vector3D(0, -1, 0);
        }
    }

    public static Vector3D forward
    {
        get
        {
            return new Vector3D(0, 0, 1);
        }
    }
    
    public static Vector3D left
    {
        get
        {
            return new Vector3D(-1, 0, 0);
        }
    }
    
    public static Vector3D right
    {
        get
        {
            return new Vector3D(1, 0, 0);
        }
    }

    public static Vector3D up
    {
        get
        {
            return new Vector3D(0, 1, 0);
        }
    }

    public static Vector3D one
    {
        get
        {
            return new Vector3D(1, 1, 1);
        }
    }

    public static Vector3D zero
    {
        get
        {
            return new Vector3D(0, 0, 0);
        }
    }

    /// <summary>
    /// 向量的长度
    /// </summary>
    public float magnitude
    {
        get
        {
            return (float)Math.Sqrt(sqrMagnitudfe);
        }
    }

    /// <summary>
    /// 向量的的长度的平方
    /// </summary>
    public float sqrMagnitudfe
    {
        get
        {
            return x * x + y * y + z * z;
        }
    }

    /// <summary>
    /// 规范化
    /// </summary>
    public Vector3D normalized
    {
        get
        {
            if (IsZero)
            {
                return Vector3D.zero;
            }
            else
            {
                Vector3D v = new Vector3D();
                float length = magnitude;
                v.x = this.x / length;
                v.y = this.y / length;
                v.z = this.z / length;
                return v;
            }
        }
    }

    /// <summary>
    /// 是否是零向量
    /// </summary>
    public bool IsZero
    {
        get
        {
            return this.x == 0 && this.y == 0 && this.z == 0;
        }
    }

    #region 操作符重载

    /// <summary>
    /// 两个向量相加
    /// </summary>
    /// <param name="a">向量a</param>
    /// <param name="b">向量b</param>
    /// <returns>两个向量的和</returns>
    public static Vector3D operator +(Vector3D a,Vector3D b)
    {
        return new Vector3D(a.x + b.x, a.y + b.y, a.z + b.z);
    }

    /// <summary>
    /// 两个向量相减
    /// </summary>
    /// <param name="a">向量a</param>
    /// <param name="b">向量b</param>
    /// <returns>两个向量的差</returns>
    public static Vector3D operator -(Vector3D a,Vector3D b)
    {
        return new Vector3D(a.x - b.x, a.y - b.y, a.z - b.z);
    }

    /// <summary>
    /// 向量取反
    /// </summary>
    /// <param name="a">向量a</param>
    /// <returns>向量a的反向量</returns>
    public static Vector3D operator -(Vector3D a)
    {
        return new Vector3D(-a.x, -a.y, -a.z);
    }

    /// <summary>
    /// 一个数乘以一个向量
    /// </summary>
    /// <param name="d">一个数</param>
    /// <param name="a">一个向量</param>
    /// <returns>返回数与向量的乘积</returns>
    public static Vector3D operator *(float d, Vector3D a)
    {
        return new Vector3D(a.x * d, a.y * d, a.z * d);
    }

    /// <summary>
    /// 一个向量乘以一个数
    /// </summary>
    /// <param name="a">一个向量</param>
    /// <param name="d">一个数</param>
    /// <returns>返回向量与数的乘积</returns>
    public static Vector3D operator *(Vector3D a, float d)
    {
        return new Vector3D(a.x * d, a.y * d, a.z * d);
    }

    /// <summary>
    /// 一个数除一个向量，向量a/数b
    /// </summary>
    /// <param name="a">一个向量</param>
    /// <param name="d">一个数</param>
    /// <returns>返回向量a/d</returns>
    public static Vector3D operator /(Vector3D a,float d)
    {
        return new Vector3D(a.x / d, a.y / d, a.z / d);
    }

    /// <summary>
    /// 两个向量是否相等
    /// </summary>
    /// <param name="lhs">向量lhs</param>
    /// <param name="rhs">向量rhs</param>
    /// <returns>如果相等，则为true，否则为false</returns>
    public static bool operator ==(Vector3D lhs, Vector3D rhs)
    {
        bool x = Math.Abs(lhs.x - rhs.x) < 0.00001f;
        bool y = Math.Abs(lhs.y - rhs.y) < 0.00001f;
        bool z = Math.Abs(lhs.z - rhs.z) < 0.00001f;
        return x && y && z;
    }

    /// <summary>
    /// 两个向量是否不等
    /// </summary>
    /// <param name="lhs">向量lhs</param>
    /// <param name="rhs">向量rhs</param>
    /// <returns>如果不等，则为true，否则为false</returns>
    public static bool operator !=(Vector3D lhs, Vector3D rhs)
    {
        return !(lhs == rhs);
    }

    #endregion

    public float x;
    public float y;
    public float z;

    private float[] data = new float[3];

    #region 构造器
    public Vector3D()
    {
        this.x = 0.0f;
        this.y = 0.0f;
        this.z = 0.0f;

        data[0] = 0.0f;
        data[1] = 0.0f;
        data[2] = 0.0f;
    }

    public Vector3D(float x, float y)
    {
        this.x = x;
        this.y = y;
        this.z = 1.0f;

        data[0] = 0.0f;
        data[1] = 0.0f;
        data[2] = 1.0f;
    }

    public Vector3D(float x, float y, float z)
    {
        this.x = x;
        this.y = y;
        this.z = z;

        data[0] = x;
        data[1] = y;
        data[2] = z;
    }

    #endregion

    public float this[int index]
    {
        get
        {
            switch (index)
            {
                case 0:
                    return this.x;
                case 1:
                    return this.y;
                case 2:
                    return this.z;
                default:
                    throw new Exception("index is out of array");
            }
        }
        set
        {
            data[index] = value;
            switch (index)
            {
                case 0:
                    this.x = value;
                    break;
                case 1:
                    this.y = value;
                    break;
                case 2:
                    this.z = value;
                    break;
                default:
                    break;
            }
        }
    }

    public override string ToString()
    {
        StringBuilder sb = new StringBuilder();
        sb.Append("(");
        sb.Append(this.x);
        sb.Append(",");
        sb.Append(this.y);
        sb.Append(",");
        sb.Append(this.z);
        sb.Append(")");
        return sb.ToString();
    }

    public void Set(float new_x, float new_y, float new_z)
    {
        this.x = new_x;
        this.y = new_y;
        this.z = new_z;
        data[0] = new_x;
        data[1] = new_y;
        data[2] = new_z;
    }

    /// <summary>
    /// 规范化，使向量长度为1
    /// </summary>
    public void Normalize()
    {
        if (!IsZero)
        {
            this.x /= magnitude;
            this.y /= magnitude;
            this.z /= magnitude;
        }
    }

    #region 静态函数

    /// <summary>
    /// 距离
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns>返回a和b之间的距离</returns>
    public static float Distance(Vector3D a, Vector3D b)
    {
        return (float)Math.Sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) + (a.z - b.z) * (a.z - b.z));
    }

    /// <summary>
    /// 计算两个向量的点乘积
    /// </summary>
    /// <param name="lhs"></param>
    /// <param name="rhs"></param>
    /// <returns></returns>
    public static float Dot(Vector3D lhs, Vector3D rhs)
    {
        return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
    }

    /// <summary>
    /// 计算两个向量的叉乘
    /// </summary>
    /// <param name="v1"></param>
    /// <param name="v2"></param>
    /// <returns></returns>
    public static Vector3D Cross(Vector3D v1, Vector3D v2)
    {
        float x = v1.y * v2.z - v2.y * v1.z;
        float y = v1.z * v2.x - v2.z * v1.x;
        float z = v1.x * v2.y - v2.x * v1.y;
        return new Vector3D(x, y, z);
    }

    /// <summary>
    /// 限制长度
    /// </summary>
    /// <param name="v">向量v</param>
    /// <param name="maxLength">最长长度</param>
    /// <returns>返回限制长度后的向量</returns>
    public static Vector3D ClampMagnitude(Vector3D v,float maxLength)
    {
        if (maxLength >= v.magnitude)
        {
            return v;
        }

        return (maxLength / v.magnitude) * v;
    }

    /// <summary>
    /// 计算两个向量的夹角
    /// </summary>
    /// <param name="from"></param>
    /// <param name="to"></param>
    /// <returns></returns>
    public static float Angle(Vector3D from,Vector3D to)
    {
        float dot = Dot(from, to);
        return (float)(180 * Math.Acos(dot / (from.magnitude * to.magnitude)) / Math.PI);
    }

    /// <summary>
    /// 投射一个向量到另一个向量
    /// </summary>
    /// <param name="vector"></param>
    /// <param name="onNormal"></param>
    /// <returns>返回被投射到onNormal的vector</returns>
    public static Vector3D Project(Vector3D vector, Vector3D onNormal)
    {
        if (vector.IsZero || onNormal == Vector3D.zero)
        {
            return Vector3D.zero;
        }
        return Dot(vector, onNormal) / (onNormal.magnitude * onNormal.magnitude) * onNormal;
    }

    /// <summary>
    /// 反射
    /// </summary>
    /// <param name="inDirection"></param>
    /// <param name="inNormal"></param>
    /// <returns></returns>
    public static Vector3D Reflect(Vector3D inDirection,Vector3D inNormal)
    {
        return Vector3D.zero;
    }

    /// <summary>
    /// 缩放
    /// </summary>
    /// <param name="scale"></param>
    public void Scale(Vector3D scale)
    {
        this.x *= scale.x;
        this.y *= scale.y;
        this.z *= scale.z;
    }
    /// <summary>
    /// 缩放
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static Vector3D Scale(Vector3D a,Vector3D b)
    {
        return new Vector3D(a.x * b.x, a.y * b.y, a.z * b.z);
    }
    
    /// <summary>
    /// 两个向量是否平行
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static bool Parallel(Vector3D a, Vector3D b)
    {
        return Cross(a,b).IsZero;
    }

    /// <summary>
    /// 两个向量之间的线性插值
    /// </summary>
    /// <param name="from">向量from</param>
    /// <param name="to">向量to</param>
    /// <param name="t"></param>
    /// <returns></returns>
    public static Vector3D Lerp(Vector3D from, Vector3D to, float t)
    {
        if (t <= 0)
        {
            return from;
        }
        else if (t >= 1)
        {
            return to;
        }
        return t * to + (1 - t) * from;
    }

    /// <summary>
    /// 两个向量的球形插值
    /// </summary>
    /// <param name="a">向量a</param>
    /// <param name="b">向量b</param>
    /// <param name="t">t的值在[0..1]</param>
    /// <returns></returns>
    public static Vector3D Slerp(Vector3D a, Vector3D b, float t)
    {
        if (t <= 0)
        {
            return a;
        }
        else if (t >= 1)
        {
            return b;
        }

        Vector3D v = RotateTo(a, b, Vector3D.Angle(a, b) * t);

        //向量的长度，跟线性插值一样计算
        float length = b.magnitude * t + a.magnitude * (1 - t);
        return v.normalized * length;
    }

    /// <summary>
    /// 将向量from向向量to旋转角度angle
    /// </summary>
    /// <param name="from"></param>
    /// <param name="to"></param>
    /// <param name="angle"></param>
    /// <returns></returns>
    public static Vector3D RotateTo(Vector3D from, Vector3D to, float angle)
    {
        //如果两向量角度为0
        if (Vector3D.Angle(from, to) == 0)
        {
            return from;
        }

        //旋转轴
        Vector3D n = Vector3D.Cross(from, to);
        n.Normalize();

        //旋转矩阵
        Matrix4x4 rotateMatrix = new Matrix4x4();

        //旋转的弧度
        double radian = angle * Math.PI / 180;
        float cosAngle = (float)Math.Cos(radian);
        float sinAngle = (float)Math.Sin(radian);
        rotateMatrix.SetRow(0, new Vector4(n.x * n.x * (1 - cosAngle) + cosAngle, n.x * n.y * (1 - cosAngle) + n.z * sinAngle, n.x * n.z * (1 - cosAngle) - n.y * sinAngle, 0));
        rotateMatrix.SetRow(1, new Vector4(n.x * n.y * (1 - cosAngle) - n.z * sinAngle, n.y * n.y * (1 - cosAngle) + cosAngle, n.y * n.z * (1 - cosAngle) + n.x * sinAngle, 0));
        rotateMatrix.SetRow(2, new Vector4(n.x * n.z * (1 - cosAngle) + n.y * sinAngle, n.y * n.z * (1 - cosAngle) - n.x * sinAngle, n.z * n.z * (1 - cosAngle) + cosAngle, 0));
        rotateMatrix.SetRow(3, new Vector4(0, 0, 0, 1));

        Vector4 v = Vector3D.ToVector4(from);
        Vector3D vector = new Vector3D();
        for (int i = 0; i < 3; ++i)
        {
            for (int j = 0; j < 3; j++)
            {
                vector[i] += v[j] * rotateMatrix[j, i];
            }
        }
        return vector;
    }

    /// <summary>
    /// 将一个Vector3D转换为Vector4
    /// </summary>
    /// <param name="v"></param>
    /// <returns></returns>
    public static Vector4 ToVector4(Vector3D v)
    {
        return new Vector4(v.x, v.y, v.z, 0);
    }

    public Vector3 ToVector3()
    {
        return new Vector3(x, y, z);
    }

    #endregion
}

以上代码只是自己在学习过程中一点成果，希望对大家有帮助，当然跟Vector3比起来肯定差很多。

以上知识分享，如有错误，欢迎指出，共同学习，共同进步。

静风霁
关注
专栏目录
unity 3D webview插件
12-27
Unity 3D Webview插件是一款专为Unity 3D开发者设计的工具，它允许你在三维游戏场景中集成网页内容，使用户能够在游戏或者应用的特定位置或对象上浏览网页。这种功能对于创建互动式体验、展示多媒体内容、提供在线...
Vector3D：一个三维向量类
Frank_bb44的博客
02-11 590
今天我心血来潮，写了一个三维向量类，叫Vector3D。
Irrlicht 源码学习笔记 【vector3d】
GY1031193940的博客
08-18 967
vector3d 模版表示一个 3D 向量 3D 点和 3D 向量是3D图形学里最基础的东西 里面有一些方法是需要一点 3D 图形学基础的，但是也非常简单喽
unity-vector3
m0_74462339的博客
07-14 206
在Unity中，Vector3是一个用于表示三维空间中的点或方向的结构。它包含三个浮点数（xyz），分别表示空间的三个轴。Vector3在游戏开发中非常常用，因为它能表示位置、方向、速度等各种物理属性。当在脚本中定义了一个vector3的变量，它可以代表向量、坐标、旋转、缩放Vector3。
【python】Vector3d的用法
Jason_C_的博客
12-03 1090
python
探索精度新境界：Unity3D双精度向量库Vector3d深度剖析与应用指南
gitblog_00002的博客
06-10 464
探索精度新境界：Unity3D双精度向量库Vector3d深度剖析与应用指南 vector3dDouble precision Vector Libraries for Unity3D项目地址:https://gitcode.com/gh_mirrors/ve/vector3d 在数字世界构建的每一寸土地上，精确度往往是决定虚拟现实细腻程度的关键。今天，我们带来了一个引人注目的开源宝藏——Vec...
Vector3D 开源项目教程
gitblog_00254的博客
08-23 423
Vector3D 开源项目教程 vector3dDouble precision Vector Libraries for Unity3D项目地址:https://gitcode.com/gh_mirrors/ve/vector3d 项目介绍 Vector3D 是一个用于处理三维向量的开源库，提供了丰富的功能来操作和计算三维空间中的向量。该库支持基本的向量运算，如加法、减法、点积、叉积等，并提供...
Unity3D脚本：点击放大图片2
08-08
Unity3D是一个跨平台的游戏引擎，它支持使用C#语言编写脚本来控制游戏对象的行为。在这个案例中，我们关注的是"Transform"组件，它是每个Unity对象的核心组成部分，包含了位置（Position）、旋转（Rotation）和缩放...
Unity3D教程：向量1
08-08
Unity3D还定义了一些预设的向量常量，如`Vector3.up`、`Vector3.right`和`Vector3.forward`，它们分别表示向上、向右和向前的方向： ```csharp var direction = Vector3.up; // 等同于 Vector3(0, 1, 0); ``` 向量...
Unity3D教程：实现表格的模拟绘制1
08-08
在Unity3D开发中，有时候我们需要创建用户界面(UI)元素来展示数据，比如表格。本教程将介绍如何在Unity3D中实现一个简单的表格模拟绘制，适用于初学者了解UI组件和基本逻辑处理。 首先，我们要知道Unity3D的UI系统...
Unity3D教程：计算机3D图形基础在Unity中的实现2
08-08
总的来说，Unity3D中的Vector3和Matrix4x4以及相关的Transform类，为开发者提供了强大的工具来创建和操控3D对象。理解和熟练掌握这些概念对于在Unity中进行3D游戏开发或应用创建至关重要。通过使用这些工具，开发者...
Unity3d之Vector3 学习与应用
热门推荐
liulala16的专栏
01-18 4万+
今天的目标是Vector3 和部分 Transform。先说Vector3。 首先是Vector3的中英文API Struct Representation of 3D vectors and points. 表示3D的向量和点。 This structure is used throughout Unity to pass 3D positions and directions
用Vector类作仿3D的flash动画
hgfghe7
04-06 148
用Vector类作仿3D的flash动画                          作者：麦长芳 引言 严格来说，这不是一篇教程，这篇文章的旨在目的是向还没有接触过Vector类的闪友介绍、推荐Vector类，利用它的方便，简洁以及它的强大功能作出更加完美的动画，特别是模仿3D的动画，说到Vector类，必须说到一个人——Robert Penner，是他在《Flash Mx编程与...
探索精度之旅：Unity3D双精度Vector3库揭秘
最新发布
gitblog_00659的博客
08-26 377
探索精度之旅：Unity3D双精度Vector3库揭秘 vector3dDouble precision Vector Libraries for Unity3D项目地址:https://gitcode.com/gh_mirrors/ve/vector3d 在游戏开发和虚拟现实领域，精确的数学运算往往决定着最终体验的细腻程度。今天，我们带来一款专为Unity3D量身打造的开源宝藏——Vector...
【Unity】Mathd系列（二）Double型Vector3
涅凡尘的专栏
03-31 4485
    Vector3可是说是比较常用的也是最容易出现精度问题的一个。经过测试发现，有一些方法跟原有的Vector3d比起来会有一定的偏差，这些都与float型的精度有关只是多数情况下近似即可。Vector3d：/// Vector3d.cs /// /// The double type version of the Unity struct Vector3. /// It can solve...
Unity3D-Vector3
weixin_38348752的博客
09-04 1716
Vector3是一个表示方向的类，既有大小也有方向 Vector3 v=new Vector3();float x=v.x;float y=v.y;float z=v.z; Vector3.up;            表示世界坐标系中y轴正方向上的单位向量。（0，1，0） Vector3.down;       表示世界坐标系中y轴负方向上的单位向量。（0，-1，0） Vector3.r
Unity—3D数学-Vector3
m0_63330263的博客
07-23 1726
Vector3 向量 向量的大小 向量的方向 向量运算 向量相减、相加 需求：t3沿着t1-t2的方向移动 向量与标量的乘除 角度度量方式： 角度Degree与弧度Radin 角度与弧度的换算 三角函数 反三角函数 练习：计算物体右前方30度，10米远坐标...
Unity --- Vector3类的API讲解
qq_51947882的博客
04-04 1265
我们最终的目的是获得动画曲线的y轴上的值来作为比例参数，且这个y轴上的值还必须随着时间变化 --- 那么实现这个需求就需要我们调用动画曲线中的放啊 -- Evaluate（） --- 在给定该方法一个单精度浮点型参数之后（要求参数范围是0到1，一旦小于0/大于1，方法只会返回0/1），它就会在动画曲线的x轴上找到这个参数的位置，并将这个位置对应的y轴值返回。1.上面这个介绍的是Vector3中的一个静态方法 --- Project（）方法，这个方法的作用是投影一个向量到另一个向量。
threejs三维向量`Vector3`简介
u014291990的博客
12-12 1864
threejs中文网如果你已经掌握了数学中关于向量的运算规则，直接去看看threejsVector3的文档，很多方法和属性都可以快速理解，比如点乘.dot()、叉乘.cross()，这时候你可以回忆你学过的数学知识来理解theejs的APIVector3中的部分方法和属性。不过有很多同学可能学过，但是都还给老师了，还有些同学干脆是没有向量的概念，这时候直接看threejs文档会不太理解，不过这没关系，下面几节课会通过threejs具体的代码案例讲解，你也不用刻意记忆这些数学概念，只要跟着课程写代码就行。
Unity3D教程：深入理解3D图形基础与Vector3应用
Unity3D教程中的这部分内容旨在帮助开发者掌握3D图形学的基础知识，包括Vector3的使用和矩阵变换，这些是构建复杂3D场景和游戏机制不可或缺的工具。通过深入学习和实践，开发者可以更有效地在Unity环境中实现3D物体...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值