在Threejs中实现沿着一条直线路径运动并伴有转向动画

最新推荐文章于 2024-06-01 15:35:03 发布
最新推荐文章于 2024-06-01 15:35:03 发布
阅读量7.1k 收藏 42
点赞数 13
分类专栏： Threejs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20535249/article/details/107611882
版权

自己定义的一个类如下：

功能：实现传入多个锚点生成一条折线并伴有锚点，
getPoint(percent)可以获取折线上任意一点的位置，并获取朝向、是否为锚点等信息。
run()方法可以让传入mesh或相机等 在折线上运动

效果如下：

Threejs直线路径动画

  //自定义路径类
        class myPath {
            constructor(array) {

                //将传进来的数组转换为Vec3集合
                let pointsArr = [];
                if (array.length % 3 !== 0) {
                    console.error('错误，数据的个数非3的整数倍！', array);
                    return null;
                }
                for (let index = 0; index < array.length; index += 3) {
                    pointsArr.push(new THREE.Vector3(array[index], array[index + 1], array[index + 2]));
                }

                //顶点位置三维向量数组
                this.pointsArr = pointsArr;

                //折线几何体
                this.line = null;
                {
                    let lineMaterial = new THREE.LineBasicMaterial({
                        color: 0xff00ff
                    });
                    let lineGeometry = new THREE.BufferGeometry().setFromPoints(pointsArr);
                    this.line = new THREE.Line(lineGeometry, lineMaterial);
                }


                //锚点几何体
                this.points = null;
                {
                    let pointsBufferGeometry = new THREE.BufferGeometry();
                    pointsBufferGeometry.setAttribute('position', new THREE.Float32BufferAttribute(array, 3));
                    let pointsMaterial = new THREE.PointsMaterial({ color: 0xffff00, size: 10 });
                    this.points = new THREE.Points(pointsBufferGeometry, pointsMaterial);
                }


                //计算每个锚点在整条折线上所占的百分比
                this.pointPercentArr = [];
                {
                    let distanceArr = []; //每段距离
                    let sumDistance = 0;  //总距离
                    for (let index = 0; index < pointsArr.length - 1; index++) {
                        distanceArr.push(pointsArr[index].distanceTo(pointsArr[index + 1]));
                    }
                    sumDistance = distanceArr.reduce(function (tmp, item) {
                        return tmp + item;
                    })


                    let disPerSumArr = [0];
                    disPerSumArr.push(distanceArr[0]);
                    distanceArr.reduce(function (tmp, item) {
                        disPerSumArr.push(tmp + item);
                        return tmp + item;
                    })

                    disPerSumArr.forEach((value, index) => {
                        disPerSumArr[index] = value / sumDistance;
                    })
                    this.pointPercentArr = disPerSumArr;
                }
                // console.log(this.pointPercentArr);


                //上一次的朝向
                this.preUp = new THREE.Vector3(0, 0, 0);



                //run函数需要的数据
                this.perce = 0; //控制当前位置占整条线百分比
                this.speed = 0.0005;  //控制是否运动
                this.turnFactor = 0;  //暂停时间因子
                this.turnSpeedFactor = 0.001; //转向速度因子
                this.obj = null;

                this.preTime = new Date().getTime();
                this.firstTurn = false;


            }

            //获取点，是否转弯，朝向等
            getPoint(percent) {

                let indexP = 0;
                let indexN = 0;
                let turn = false;

                for (let i = 0; i < this.pointPercentArr.length; i++) {
                    if (percent >= this.pointPercentArr[i] && percent < this.pointPercentArr[i + 1]) {
                        indexN = i + 1;
                        indexP = i;
                        if (percent === this.pointPercentArr[i]) {
                            turn = true;
                        }
                    }
                }

                let factor = (percent - this.pointPercentArr[indexP]) / (this.pointPercentArr[indexN] - this.pointPercentArr[indexP]);
                let position = new THREE.Vector3();
                position.lerpVectors(this.pointsArr[indexP], this.pointsArr[indexN], factor); //position的计算完全正确




                //计算朝向
                let up = new THREE.Vector3().subVectors(this.pointsArr[indexN], this.pointsArr[indexP]);
                let preUp = this.preUp;
                if (this.preUp.x != up.x || this.preUp.y != up.y || this.preUp.z != up.z) {

                    console.info('当前朝向与上次朝向不等，将turn置为true！');
                    turn = true;
                }

                this.preUp = up;


                return {
                    position,
                    direction: up,

                    turn, //是否需要转向
                    preUp, //当需要转向时的上次的方向

                };

            }


            //参数：是否运动，运动的对象，是否运动到结尾
            run(animata, camera, end) {

                if (end) {

                    this.perce = 0.99999;
                    this.obj = this.getPoint(this.perce);

                    //修改位置
                    let posi = this.obj.position;

                    // cone.position.set(posi.x, posi.y, posi.z);
                    camera.position.set(posi.x, posi.y, posi.z); //相机漫游2
                }

                else if (animata) {

                    //转弯时
                    if (this.obj && this.obj.turn) {

                        if (this.turnFactor == 0) {
                            this.preTime = new Date().getTime();
                            this.turnFactor += 0.000000001;
                        }
                        else {
                            let nowTime = new Date().getTime();
                            let timePass = nowTime - this.preTime;
                            this.preTime = nowTime;

                            this.turnFactor += this.turnSpeedFactor * timePass;
                        }


                        //console.log('--->>> 当前需要turn , turnFactor值为 :', this.turnFactor);
                        if (this.turnFactor > 1) {
                            this.turnFactor = 0;
                            this.perce += this.speed;

                            this.obj = this.getPoint(this.perce);
                        }

                        else {

                            //修改朝向 (向量线性插值方式)
                            let interDirec = new THREE.Vector3();
                            interDirec.lerpVectors(this.obj.preUp, this.obj.direction, this.turnFactor);

                            let look = new THREE.Vector3();
                            look = look.add(this.obj.position);
                            look = look.add(interDirec);

                            // cone.lookAt(look);
                            camera.lookAt(look);  //相机漫游1
                        }

                    }

                    //非转弯时
                    else {

                        this.obj = this.getPoint(this.perce);

                        //修改位置
                        let posi = this.obj.position;

                        // cone.position.set(posi.x, posi.y, posi.z);
                        camera.position.set(posi.x, posi.y, posi.z); //相机漫游2


                        //当不需要转向时进行
                        if (!this.obj.turn) {
                            let look = posi.add(this.obj.direction);

                            // cone.lookAt(look);
                            camera.lookAt(look); //相机漫游3
                        }
                        this.perce += this.speed;

                    }
                }


            }
        }

使用案例：

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>run</title>
    <style>
        html,
        body {
            margin: 0;
            padding: 0;
            height: 100%;
        }

        div {
            width: 100%;
            height: 100%;
            position: absolute;
            top: 0;
            /* left: 0; */
        }

        .buttons {
            position: absolute;
            top: 0;
            right: 0;
            width: 20%;
            height: 10%;
            /* background-color: darkgrey; */
            z-index: 999;
        }

        input {
            width: 100%;
            cursor: pointer;
        }
    </style>
</head>

<body>


    <div class="buttons">
        <input id='start' type="button" value="START">
        <input id="stop" type="button" value="STOP">
        <input id='end' type="button" value="END">
        <input id='toggle' type="button" value="切换">
    </div>


    <script type="module">

        import * as THREE from './build/three.module.js';
        import { OrbitControls } from "./jsm/controls/experimental/CameraControls.js";


        let scene = new THREE.Scene();
        scene.background = new THREE.Color('gray');

        let camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 10000);
        camera.position.set(250, 250, 250);

        let renderer = new THREE.WebGLRenderer({ alpha: false });
        renderer.setSize(window.innerWidth, window.innerHeight);
        document.body.appendChild(renderer.domElement);

        let controls = new OrbitControls(camera, renderer.domElement);

        {
            let directionalLight = new THREE.DirectionalLight(0xffffff, 0.5);
            directionalLight.position.set(1, 1, 1);
            scene.add(directionalLight);

            let light = new THREE.AmbientLight(0x404040); // soft white light
            scene.add(light);

            let axesHelper = new THREE.AxesHelper(5000);
            scene.add(axesHelper);
        }
        /************场景布置结束**************/


        //添加星空背景
        {
            let vertices = [];

            for (let i = 0; i < 10000; i++) {

                let x = THREE.MathUtils.randFloatSpread(2000);
                let y = THREE.MathUtils.randFloatSpread(2000);
                let z = THREE.MathUtils.randFloatSpread(2000);

                vertices.push(x, y, z);

            }

            let geometry6 = new THREE.BufferGeometry();
            geometry6.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));

            let material6 = new THREE.PointsMaterial({ color: 0xffffff, size: 0.5 });

            let starPoints = new THREE.Points(geometry6, material6);

            scene.add(starPoints);
        }



        let material = new THREE.MeshBasicMaterial({ color: 0xff0000 });
        let geometry = new THREE.CylinderBufferGeometry(0, 10, 50, 12);
        geometry.rotateX(Math.PI / 2);
        let cone = new THREE.Mesh(geometry, material);
        scene.add(cone);




        //自定义路径类
        class myPath {
            constructor(array) {

                //将传进来的数组转换为Vec3集合
                let pointsArr = [];
                if (array.length % 3 !== 0) {
                    console.error('错误，数据的个数非3的整数倍！', array);
                    return null;
                }
                for (let index = 0; index < array.length; index += 3) {
                    pointsArr.push(new THREE.Vector3(array[index], array[index + 1], array[index + 2]));
                }

                //顶点位置三维向量数组
                this.pointsArr = pointsArr;

                //折线几何体
                this.line = null;
                {
                    let lineMaterial = new THREE.LineBasicMaterial({
                        color: 0xff00ff
                    });
                    let lineGeometry = new THREE.BufferGeometry().setFromPoints(pointsArr);
                    this.line = new THREE.Line(lineGeometry, lineMaterial);
                }


                //锚点几何体
                this.points = null;
                {
                    let pointsBufferGeometry = new THREE.BufferGeometry();
                    pointsBufferGeometry.setAttribute('position', new THREE.Float32BufferAttribute(array, 3));
                    let pointsMaterial = new THREE.PointsMaterial({ color: 0xffff00, size: 10 });
                    this.points = new THREE.Points(pointsBufferGeometry, pointsMaterial);
                }


                //计算每个锚点在整条折线上所占的百分比
                this.pointPercentArr = [];
                {
                    let distanceArr = []; //每段距离
                    let sumDistance = 0;  //总距离
                    for (let index = 0; index < pointsArr.length - 1; index++) {
                        distanceArr.push(pointsArr[index].distanceTo(pointsArr[index + 1]));
                    }
                    sumDistance = distanceArr.reduce(function (tmp, item) {
                        return tmp + item;
                    })


                    let disPerSumArr = [0];
                    disPerSumArr.push(distanceArr[0]);
                    distanceArr.reduce(function (tmp, item) {
                        disPerSumArr.push(tmp + item);
                        return tmp + item;
                    })

                    disPerSumArr.forEach((value, index) => {
                        disPerSumArr[index] = value / sumDistance;
                    })
                    this.pointPercentArr = disPerSumArr;
                }
                // console.log(this.pointPercentArr);


                //上一次的朝向
                this.preUp = new THREE.Vector3(0, 0, 0);



                //run函数需要的数据
                this.perce = 0; //控制当前位置占整条线百分比
                this.speed = 0.0005;  //控制是否运动
                this.turnFactor = 0;  //暂停时间因子
                this.turnSpeedFactor = 0.001; //转向速度因子
                this.obj = null;

                this.preTime = new Date().getTime();
                this.firstTurn = false;


            }

            //获取点，是否转弯，朝向等
            getPoint(percent) {

                let indexP = 0;
                let indexN = 0;
                let turn = false;

                for (let i = 0; i < this.pointPercentArr.length; i++) {
                    if (percent >= this.pointPercentArr[i] && percent < this.pointPercentArr[i + 1]) {
                        indexN = i + 1;
                        indexP = i;
                        if (percent === this.pointPercentArr[i]) {
                            turn = true;
                        }
                    }
                }

                let factor = (percent - this.pointPercentArr[indexP]) / (this.pointPercentArr[indexN] - this.pointPercentArr[indexP]);
                let position = new THREE.Vector3();
                position.lerpVectors(this.pointsArr[indexP], this.pointsArr[indexN], factor); //position的计算完全正确




                //计算朝向
                let up = new THREE.Vector3().subVectors(this.pointsArr[indexN], this.pointsArr[indexP]);
                let preUp = this.preUp;
                if (this.preUp.x != up.x || this.preUp.y != up.y || this.preUp.z != up.z) {

                    console.info('当前朝向与上次朝向不等，将turn置为true！');
                    turn = true;
                }

                this.preUp = up;


                return {
                    position,
                    direction: up,

                    turn, //是否需要转向
                    preUp, //当需要转向时的上次的方向

                };

            }


            //参数：是否运动，运动的对象，是否运动到结尾
            run(animata, camera, end) {

                if (end) {

                    this.perce = 0.99999;
                    this.obj = this.getPoint(this.perce);

                    //修改位置
                    let posi = this.obj.position;

                    // cone.position.set(posi.x, posi.y, posi.z);
                    camera.position.set(posi.x, posi.y, posi.z); //相机漫游2
                }

                else if (animata) {

                    //转弯时
                    if (this.obj && this.obj.turn) {

                        if (this.turnFactor == 0) {
                            this.preTime = new Date().getTime();
                            this.turnFactor += 0.000000001;
                        }
                        else {
                            let nowTime = new Date().getTime();
                            let timePass = nowTime - this.preTime;
                            this.preTime = nowTime;

                            this.turnFactor += this.turnSpeedFactor * timePass;
                        }


                        console.log('--->>> 当前需要turn , turnFactor值为 :', this.turnFactor);
                        if (this.turnFactor > 1) {
                            this.turnFactor = 0;
                            this.perce += this.speed;

                            this.obj = this.getPoint(this.perce);
                        }

                        else {

                            //修改朝向 (向量线性插值方式)
                            let interDirec = new THREE.Vector3();
                            interDirec.lerpVectors(this.obj.preUp, this.obj.direction, this.turnFactor);

                            let look = new THREE.Vector3();
                            look = look.add(this.obj.position);
                            look = look.add(interDirec);

                            // cone.lookAt(look);
                            camera.lookAt(look);  //相机漫游1
                        }

                    }

                    //非转弯时
                    else {

                        this.obj = this.getPoint(this.perce);

                        //修改位置
                        let posi = this.obj.position;

                        // cone.position.set(posi.x, posi.y, posi.z);
                        camera.position.set(posi.x, posi.y, posi.z); //相机漫游2


                        //当不需要转向时进行
                        if (!this.obj.turn) {
                            let look = posi.add(this.obj.direction);

                            // cone.lookAt(look);
                            camera.lookAt(look); //相机漫游3
                        }
                        this.perce += this.speed;

                    }
                }


            }
        }




        let a = new myPath([
            0, 0, 0,
            500, 0, 0,
            500, 0, 500,
            0, 0, 500,
            0, 500, 500,
            500, 750, 0,
        ]);

        scene.add(a.points);
        scene.add(a.line);



        let startFlag = true;
        let endFlag = false;
        let toggleFlag = true;
        let runMesh = cone;

        document.getElementById('start').onclick = function timeStart() {
            console.log('点击了start');
            startFlag = true;
            endFlag = false;
        };

        document.getElementById('stop').onclick = function timeStart() {
            console.log('点击了stop');
            startFlag = false;
        };

        document.getElementById('end').onclick = function timeStart() {
            console.log('点击了end');
            endFlag = true;
        };

        document.getElementById('toggle').onclick = function timeStart() {
            console.log('点击了toggle');
            toggleFlag = !toggleFlag;
            if(toggleFlag){
                runMesh = cone;
                camera.position.set(500,500,500);
            }
            else{
                runMesh = camera;
            }

        };




        let animate = function () {

            requestAnimationFrame(animate);
            controls.update();


            a.run(startFlag, runMesh, endFlag);

            //路程循环
            if (a.perce >= 1) {
                a.perce = 0;
            }


            renderer.render(scene, camera);
        };

        animate();
    </script>

</body>

</html>
我想_iwant
关注
  • 13
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
three.js仿人行走的动画效果
04-08
利用three导入json模型 饼渲染 加上three自带的动画效果 模拟像人一样走路的动画。
Threejs 中学shader001----three.js中使用GLSL指南
qq_21476953的博客
09-10 2680
https://qiita.com/kitasenjudesign/items/1657d9556591284a43c8 输入和输出 VertexShader 没有输入 在2D平面上输出gl_Position（vec4）顶点坐标 输出gl_PointSize（float）点的大小 FragmentShader 输入gl_FrontFacing（bool）多边形的前后布尔值 输入gl_Fr...
threejs 动画效果的实现与高级技巧
最新发布
v17191194242的博客
06-01 760
艾斯视觉作为行业ui设计与前端开发服务商很高兴能在这里与你共同探讨：通过掌握 Three.js 中动画效果的实现方法和高级技巧，开发者能够创造出极具魅力的三维场景和互动体验。展示一些实际项目中运用多种动画效果和高级技巧的场景，如一个具有复杂角色动作的游戏场景或一个动态展示的机械模型。随着技术的不断进步，Three.js 的动画效果将变得更加丰富和强大，可能会引入新的动画技术和特性。可以设置动画的循环方式，如单次播放、循环播放等，以及通过代码来控制动画的开始、暂停、停止等操作。
threejs模拟车辆行驶转弯（车头转向）
qq_33069557的博客
05-08 6171
受疫情影响，开学不成，于是乎找了个公司实习。略微学过一点cesium，但是领导要求我使用three.js搭建一个智慧园区，我… 好在是实习生，每天不用做什么事情，只需要看看网上教程就行了。边学边总结，关于three.js的官方资源不是特别多，一些好的例子也不多，只能慢慢找慢慢摸索。 我也一边学习一边记录一下我的学习过程，如果能帮到后来的人就更好了，也算是做了一点点贡献了，话不多说，开始！ 模拟车辆，首先得有车辆，然后车辆得动。问题来了，车辆怎么动？于是我查了一下，找到了这篇文章，代码效果如下。 这是我的最
Web 3D全景图（全景漫游）-WebGL/Threejs技术倾心打造
ALLENJIAO的专栏
06-24 8615
全景虚拟漫游 ThreeJS是一个3D的JS库，封装了WebGL的功能。而WebGL（Web Graphic Library）又是什么呢，简而言之，就是在浏览器端开发3D图形相关的程序的一个库或者说一个标准。 功能介绍 可以加载单张和六张的全景图；热点、标注、标注定位、tips显示、svg图形显示、html标签显示 更多细节和功能改进后续赘述，感兴趣的可以留言或发...
原生js使用canvas实现鼠标绘制直线
weixin_72388638的博客
04-08 4043
直线可以看成是一小段一小段的线段组成，并且两点确定一条直线；首先当鼠标左键点击时候获取鼠标左键xy坐标，把当前获取得到的xy坐标赋值给线段起始点的坐标值，当鼠标移动后再获取新的鼠标位置x2和y2 再把获取得到到x2和y2赋值给线段的末尾点坐标值 ，之后两点连起来就是一段线段。之后再画一条线段，只要把前面那段线段的末尾点为起始点，再获取鼠标移动时候产生的新点，把两端相连就是一大段线段，如此重复。
Threejs入门之二十四：Threejs中的Animation动画
九仞山的专栏
04-18 4555
详细介绍了Threejs中的动画API，并通过一个实例实现了移动动画和旋转动画，对Threejs中的关键帧轨道、动画剪辑、动画混合器和动画动作进行了详细介绍
ThreeJS使用Curve曲线让物体沿轨迹运动DEMO
12-09
本示例"ThreeJS使用Curve曲线让物体沿轨迹运动DEMO"探讨了如何利用Three.js中的Curve类来创建自定义的路径，并使物体沿着这条路径移动。 首先，让我们理解什么是Curve。在Three.js中，Curve是定义二维空间中路径的...
使用three.js实现室内路径规划demo
05-21
使用three.js基于已有的路径和节点数据 使用d算法实现室内地图点选路径规划 具体效果参见我的博客：https://blog.csdn.net/u014529917/article/details/100424812
基于three.js实现的炫酷3D线条背景动画特效
06-12
在实现这个3D线条动画的过程中，首先需要理解three.js的基本概念，如场景(Scene)、相机(Camera)、光源(Light)以及几何体(Geometry)和材质(Material)。场景是3D世界的容器，相机定义了观察者的位置和视角，光源则影响...
three.js-线上运动的光效
10-19
标题 "three.js-线上运动的光效" 指向的是一个使用 three.js 库创建的、关于在线环境中动态光线效果的项目。three.js 是一个流行的JavaScript库，用于在Web浏览器中创建3D图形，它利用 WebGL 技术提供丰富的三维渲染...
基于three.js的炫酷Canvas 3D线条动画特效
12-12
html5-canvas-animation是一款基于three.js的HTML5 canvas 3D线条动画特效。该3D线条动画特效可以用鼠标进行互动，canvas的背景颜色可以随机改变。你可以使用它来制作页面顶部的Banner，效果会非常的酷。
Threejs实现滴滴官网首页地球动画功能
10-15
《Threejs实现滴滴官网首页地球动画功能详解》 Threejs，作为一款强大的WebGL库，使得在浏览器中创建3D图形变得简单易行。本文将深入探讨如何利用Threejs来复现滴滴官网首页的地球动画效果。我们将从基础的3D场景...
动画化网格线：Three.js 的创新之作
gitblog_00056的博客
05-18 298
动画化网格线：Three.js 的创新之作 项目地址:https://gitcode.com/Jeremboo/animated-mesh-lines 在三维渲染的世界中，线条的动态表现力常常能为场景增添无尽的魅力和深度。今天我们要向您介绍一个令人兴奋的开源项目——Animated Mesh Lines，由 Jérémie Boulay 创作，基于流行的 JavaScript 三维库 Three....
学习 Three.js (2) —— 物体的位移缩放旋转和父子层级关系
weixin_52872413的博客
11-07 318
上篇介绍了 three.js 的入门操作和基本的代码，这篇来讲述如何操控物体的变化，以及父子层级关系。
three.js DragControls +TransformControls 实现沿轴线拖拽功能
qq_40765480的博客
04-07 1721
three.js 实现沿轴线拖拽功能
three.js鼠标控制场景旋转
w__qwwq的博客
09-06 1434
three.js 鼠标控制场景旋转
35three.js鼠标控制物体旋转缩放
X01动力装甲的专栏
06-14 3576
three.js包含了很多相机控制器，通过旋转相机可以达到同样的旋转效果。 但是当我们需要固定场景背景，固定固定摄像机的时候。我们只能去移动物体了。Three.js提供了 TransformControls.js控件，它可以控制物体的旋转、缩放、平移，但是使用起来并不方便。 这个时候就需要自己动手写控制器了。 原理很简单：获取鼠标（手势）点击的位置，以及鼠标拖动的距离。 把移动...
ThreeJS 动画之 Noisy Lines
南城
05-07 415
五一假期即将结束啦，大家也即将准备投入到工作中来了，在这假期的最后一天，给大家带来一个复杂的线条动画，效果如下所示。 gif 如果你做过一些企业站点的项目，应该会有遇到过这种需求，为了让我们的站点更具有活力及动画效果，往往会加一些类似这样的效果来丰富我们的网站，今天就来看看如何实现这种效果吧，动画效果基于threejs-toys实现，本文不讨论其底层原理，有兴趣的同学可以看看源码研究。 实现 引入依赖包 import{noisyLinesBackground}from'https:...
threejs实现模型沿着一条曲线移动，移动到曲线终点后暂停，然后沿着另一条曲线移动
04-19
很高兴回答您的问题！关于three.js实现模型沿着曲线移动并暂停，您可以使用CurvePath和Tween.js库。首先，您需要创建一条曲线，使用CurvePath将该曲线添加到路径中，然后使用Tween.js库将模型沿着该路径移动。当模型移动到曲线终点时，您可以使用Tween.js库的回调函数暂停模型的移动。然后，您可以创建另一条曲线并重复以上步骤。如果您需要更具体的代码示例和实现说明，可以在网上查找相关教程或参考Three.js官方文档。希望这能帮助到您！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值