Android 两个Activity之间切换

最新推荐文章于 2024-04-10 14:52:13 发布
原创 最新推荐文章于 2024-04-10 14:52:13 发布 · 605 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细记录了从主Activity（MainActivity）到副Activity（OtherActivity）的启动、暂停、重启、销毁及横竖屏切换过程的生命周期变化，包括onCreate, onStart, onResume, onPause, onStop和onDestroy等关键方法的调用顺序。

有两个Activity，其中主Activity是MainActivity，副Activity是OtherActivity。

启动MainActivity后经历的过程如下：

10-07 03:19:23.624: I/MainActivity(505): onCreate
10-07 03:19:23.624: I/MainActivity(505): onStart
10-07 03:19:23.624: I/MainActivity(505): onResume
点击启动新的activity按钮后经历的过程如下：

10-07 03:19:32.674: I/MainActivity(505): onPause
10-07 03:19:32.744: I/MainActivity(505): OtherActivity.onCreate
10-07 03:19:32.744: I/MainActivity(505): OtherActivity.onStart
10-07 03:19:32.744: I/MainActivity(505): OtherActivity.onResume
10-07 03:19:33.144: I/MainActivity(505): onStop
点击返回按键后经历的过程如下：

10-07 03:20:11.444: I/MainActivity(505): OtherActivity.onPause
10-07 03:20:11.474: I/MainActivity(505): onRestart
10-07 03:20:11.474: I/MainActivity(505): onStart
10-07 03:20:11.474: I/MainActivity(505): onResume
10-07 03:20:11.803: I/MainActivity(505): OtherActivity.onStop
10-07 03:20:11.803: I/MainActivity(505): OtherActivity.onDestroy
再次点击返回按键后经历的过程如下：

10-07 03:20:53.554: I/MainActivity(505): onPause
10-07 03:20:54.174: I/MainActivity(505): onStop
10-07 03:20:54.174: I/MainActivity(505): onDestroy

 

横竖屏切换经历的过程如下：

10-20 14:30:22.125: I/MainActivity(10360): onPause
10-20 14:30:22.750: I/MainActivity(10360): onStop
10-20 14:30:22.750: I/MainActivity(10360): onDestroy
10-20 14:30:24.976: I/MainActivity(10360): onCreate()
10-20 14:30:24.976: I/MainActivity(10360): onStart
10-20 14:30:24.976: I/MainActivity(10360): onResume

Android android:documentLaunchMode属性和FLAG_ACTIVITY_NEW_DOCUMENT说明
woai110120130的专栏
12-13 5340
        其实“最近使用的应用”屏幕添加链接描述 这篇文章已经写的很清楚了，但是网上的很多介绍都是翻译的api文档，让人看了一头雾水，这里再给大家科普一下。         首先要知道Android的最近任务里面的显示是以任务为单位的， 一般清空下Android程序按照应用按照应用包名来组织task, 或者按照taskAffinity来组织逻辑
【android开发】解决输入法与表情面板切换时的界面抖动问题
蓝亭书序
11-28 3097
昨天琢磨了下android的输入法弹出模式，突然发现利用动态切换输入法的弹出模式可以解决输入法抖动的问题。具体是怎样的抖动呢？我们先看微博的反面教材。 【具体表现为：表情面板与输入法面板高度不一致，从而导致弹出输入法(layout被挤压)时，同时又需要隐藏表情面板(layout被拉升)，最终让界面产生了高度差抖动，所以在切换时明显会有不大好的抖动体验)】使用了解决抖动的解决方案后，效果如下：
android 两个activity 翻转动画切换
02-20
android 两个activity 翻转动画切换。谁如果把activity切换时的动画连贯了。给我说一下。
Android使用两个Activity页面切换…
灵思致远Leansmall的博客
05-30 1135
完成大写转换并返回结果 两个页面XML文件如下： 1.activity_main.xml:     android:layout_width="fill_parent"     android:layout_height="fill_parent"     android:orientation="vertical" >             android:id="@+id/editTex
安卓自学笔记：17：两个Activity之间的切换
程序猿的自学之路
11-30 777
通过Intent实现两个Activity之间的切换。但是，需要注意一下的是要在AndroidManifest.xml中配置要start的activity，特别注意：只能出现在其中一个activity中，该标签用来告诉Android系统哪个activity是用来接收程序初始化启动的intent，android.intent.action.MAIN决定应用程序最先启动的activity，android
Android学习笔记——两个Activity之间的切换
ps_zhanglei的专栏
08-05 2194
因为是两个Activity所以需要定义两个布局文件，需要点击按钮来进行两个界面之间的切换，所以在 main.xm: <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_
Android开发基础之Activity，图解Activity状态与生命周期
WYuan的博客
06-09 3425
目录一、Activity是什么？二、Activity状态三、Activity生命周期 一、Activity是什么？         Activity是Android的四大组件之一，Activity利用View来实现应用程序的图形用户界面GUI，而手机用户则是通过GUI和应用程序做交互。         对于每个activity，系统会分配一个默认窗口。一个应用程序需要多少个activity？每个activity表示什么样的界面？
Android导航组件Navigation从入门到精通
yingaizhu的博客
05-14 2万+
一、前言     传统的应用开发，一般都是采用一个界面一个 Activity 的形式，但是大家都知道， Activity 在 Android 中是属于重量级的组件，从而导致程序资源消耗大，用户体验不佳。而导航组件 Navigation 采用的是 Fragment 轻量级的组件实现的，可以节省资源，提高用户体验。 二、导航简介   &nbs...
深入理解Android系统多用户
热门推荐
ulangch的博客
07-05 3万+
一、引言 这篇文章以Android v28的源码为参考，介绍Android多用户的特性、使用方式和系统原理。 二、初识Android多用户 2.1 Android多用户简介 从Android 4.0开始，Google就开始在Android上布局多用户，UserManager因此而诞生，然而此时还没有对应的Binder服务。真正支持多用户是从Android 4.2 开始，即便如此，系统中也依然存...
Android编程实现两个Activity相互切换而不使用onCreate()的方法
01-20
本文实例讲述了Android编程实现两个Activity相互切换而不使用onCreate()的方法。分享给大家供大家参考，具体如下： 这里要实现的目的是： 有3个Activity: A,B,C，从A中可以进入B，B中可以进入C，并且B和C之间可能需要多次相互切换，因此不能使用普通的startActivity-finish方式，因为重新创建Activity比较耗时。当这个Activity内容比较多时，重复创建很大的影响了流畅性。（即实现类似于QQ上 选择照片页面-选择相册页面，这两个页面可能多次相互切换，所以不能多次创建） 1.从B进入C或者从C进入B时，均使用startActivity的方式（
Android使用两个Activity页面切换… 分类： Androi...
weixin_30578677的博客
05-30 150
两个XML文件如下： 1.slave.xml android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" > android:id="@+id/button1" an...
Activity两种切换方式
zhoujun798的博客
04-10 361
首先创建一个Intent对象，指定当前Activity（CurrentActivity.this）和要启动的目标Activity（NextActivity.class）；要将一个Activity入栈（即启动一个新的Activity并将其添加到Activity堆栈中），可以使用Intent和startActivity()方法。然后使用startActivity()方法启动目标Activity，将其添加到Activity堆栈中。
android activity相互切换,Android编程实现两个Activity相互切换而不使用onCreate()的方法...
weixin_30562977的博客
05-29 409
本文实例讲述了Android编程实现两个Activity相互切换而不使用onCreate()的方法。分享给大家供大家参考，具体如下：这里要实现的目的是：有3个Activity: A,B,C，从A中可以进入B，B中可以进入C，并且B和C之间可能需要多次相互切换，因此不能使用普通的startActivity-finish方式，因为重新创建Activity比较耗时。当这个Activity内容比较多时，重...
Android中不同Activity的切换
topMan'blog
11-02 256
                         在android的开发中不同页面中Activity的切换以及原理讲解，本实例中从ActivityBundle页面中切换至ResultActivity，点击返回至返回页面： 原理将页面ActivityBundle切换ResultActivity页面，将height,sex信息存储在Bundle中，在另一个页面中获取： //通过inte...
android开发activity切换,Android编程实现两个Activity相互切换而不使用onCreate()的方法...
weixin_26782929的博客
05-28 890
本文实例讲述了Android编程实现两个Activity相互切换而不使用onCreate()的方法。分享给大家供大家参考，具体如下：这里要实现的目的是：有3个Activity: A,B,C，从A中可以进入B，B中可以进入C，并且B和C之间可能需要多次相互切换，因此不能使用普通的startActivity-finish方式，因为重新创建Activity比较耗时。当这个Activity内容比较多时，重...
c语言中两个android,Android：实现两个Activity相互切换而都不走onCreate()
weixin_39946767的博客
05-28 174
本文要实现的目的是：有3个Activity: A,B,C，从A中可以进入B，B中可以进入C，并且B和C之间可能需要多次相互切换，因此不能使用普通的startActivity-finish方式，因为重新创建Activity比较耗时。当这个Activity内容比较多时，重复创建很大的影响了流畅性。(即实现类似于QQ上 选择照片页面-选择相册页面，这两个页面可能多次相互切换，所以不能多次创建)1.从B进...
//1.mesh构建 using System.Collections; using System.Collections.Generic; using UnityEngine; [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer), typeof(MeshCollider))] public class Potteryprototype : MonoBehaviour {     MeshFilter meshFilter;     MeshRenderer meshRenderer;     MeshCollider meshCollider;     Mesh mesh;       public int details = 40;     public int layer = 20;     public float Height = 0.1f;       public float OuterRadius = 1.0f;     public float InnerRadius = 0.9f;       List<Vector3> vertices;     List<Vector2> UV;     List<int> triangles;       float EachAngle ;     int SideCount;       public MouseControl mouse;       void Start()     {         meshFilter = GetComponent<MeshFilter>();         meshCollider = GetComponent<MeshCollider>();         meshRenderer = GetComponent<MeshRenderer>();     }       [ContextMenu("GeneratePottery")]     void GeneratePrototype()     {         vertices = new List<Vector3>();         triangles = new List<int>();         UV = new List<Vector2>();           EachAngle = Mathf.PI * 2 / details;         for (int i = 0; i < layer; i++)         {             GenerateCircle(i);         }         Capping();                 mesh = new Mesh();         mesh.vertices = vertices.ToArray();         mesh.triangles = triangles.ToArray();         mesh.uv = UV.ToArray();           mesh.RecalculateBounds();         mesh.RecalculateTangents();           meshFilter.mesh = mesh;         mesh.RecalculateNormals();         meshCollider.sharedMesh = mesh;     }       void GenerateCircle(int _layer)     {         //外顶点与内顶点分开存储,方便变化操作时的计算         List<Vector3> vertices_outside = new List<Vector3>();         List<Vector3> vertices_inside = new List<Vector3>();                  List<Vector2> UV_outside = new List<Vector2>();         List<Vector2> UV_inside = new List<Vector2>();             //外侧和内侧顶点计算         //注意这里让每一圈的首尾重合了,也就是开始和结尾的顶点坐标一致         //目的是计算UV坐标时不会出现空缺         for (float i = 0; i <= Mathf.PI * 2+EachAngle; i += EachAngle)         {             Vector3 v1 = new Vector3(OuterRadius * Mathf.Sin(i),  _layer * Height, OuterRadius * Mathf.Cos(i));             Vector3 v2 = new Vector3(OuterRadius * Mathf.Sin(i),  (_layer +1)* Height, OuterRadius * Mathf.Cos(i));             Vector3 v3 = new Vector3(InnerRadius * Mathf.Sin(i),  _layer * Height, InnerRadius * Mathf.Cos(i));             Vector3 v4 = new Vector3(InnerRadius * Mathf.Sin(i),  (_layer+1) * Height, InnerRadius * Mathf.Cos(i));             vertices_outside.Add(v1); vertices_outside.Add(v2);             vertices_inside.Add(v3); vertices_inside.Add(v4);               Vector2 uv1 = new Vector2(i / Mathf.PI*2, _layer*1.0f / layer * 1.0f);             Vector2 uv2 = new Vector2(i / Mathf.PI*2, (_layer + 1)*1.0f / layer * 1.0f);             Vector2 uv3 = new Vector2(i / Mathf.PI*2, _layer*1.0f / layer * 1.0f);             Vector2 uv4 = new Vector2(i / Mathf.PI*2, (_layer + 1) *1.0f/ layer * 1.0f);             UV_outside.Add(uv1); UV_outside.Add(uv2);             UV_inside.Add(uv3); UV_inside.Add(uv4);         }         vertices.AddRange(vertices_outside);         vertices.AddRange(vertices_inside);           UV.AddRange(UV_outside);         UV.AddRange(UV_inside);           SideCount = vertices_outside.Count;         int j = vertices_outside.Count * _layer * 2;         int n = vertices_outside.Count;         for (int i = j; i < j + vertices_outside.Count - 2; i += 2)         {               triangles.Add(i); triangles.Add(i + 2); triangles.Add(i + 1);             triangles.Add(i + 2); triangles.Add(i + 3); triangles.Add(i + 1);               triangles.Add(i + n); triangles.Add(i + n + 1); triangles.Add(i + n + 2);             triangles.Add(i + n + 2); triangles.Add(i + n + 1); triangles.Add(i + n + 3);         }          }     //封顶,底面由于看不见就不用管了     void Capping()     {                 for (float i = 0; i <= Mathf.PI * 2+EachAngle; i += EachAngle)         {             Vector3 outer = new Vector3(OuterRadius * Mathf.Sin(i),layer * Height, OuterRadius * Mathf.Cos(i));             Vector3 inner= new Vector3(InnerRadius * Mathf.Sin(i), layer * Height, InnerRadius * Mathf.Cos(i));               vertices.Add(outer);vertices.Add(inner);               Vector2 uv1 = new Vector2(i / Mathf.PI * 2,0); Vector2 uv2 = new Vector2(i / Mathf.PI * 2, 1);                         UV.Add(uv1); UV.Add(uv2);         }         int j = SideCount * layer * 2;         for (int i=j;i<vertices.Count-2;i+=2)         {             triangles.Add(i);triangles.Add(i + 3);triangles.Add(i + 1);             triangles.Add(i);triangles.Add(i + 2);triangles.Add(i + 3);         }         triangles.Add(vertices.Count - 2);triangles.Add(j + 1);triangles.Add(vertices.Count - 1);         triangles.Add(vertices.Count - 2);triangles.Add(j);triangles.Add(j + 1);             } }   //2.动态改变形状 //这个函数放在Update()里调用     void GetMouseControlTransform()     {         //从屏幕鼠标位置发射一条射线到模型上,获取这个坐标         Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);         RaycastHit info;           if (Physics.Raycast(ray.origin, ray.direction, out info))         {               //在Unity中无法直接修改MeshFilter中Mesh的信息,需要新建一个Mesh修改其引用关系             Mesh mesh = meshFilter.mesh;             Vector3[] _vertices = mesh.vertices;               for (int i = 0; i < _vertices.Length; i++)             {                   //x,z平面变换                 //顶点移动与Y值的关系限制在5倍单层高度                 //这里可以自行修改,限制高度越大,曲线越平滑                 if (Mathf.Abs(info.point.y - transform.TransformPoint(_vertices[i]).y) < (5 * Height))                 {                     //计算顶点移动方向的向量                     Vector3 v_xz = (transform.TransformPoint(_vertices[i]) - new Vector3(transform.position.x, transform.TransformPoint(_vertices[i]).y, transform.position.z));                       //外顶点与内顶点移动时相对距离应该保持不变                     //因为我们知道顶点数组内的顺序关系,所以可以通过计算总顶点数除以每层单侧顶点数的商的奇偶关系来判断是外顶点还是内顶点                     int n = i / SideCount;                     bool side = n % 2 == 0;                     //判断顶面顶点内外关系                     bool caps = (i - (SideCount * layer * 2)) % 2 == 0;                       //限制每个顶点最大和最小的移动距离                     float max;                     float min;                     if (i < SideCount * layer * 2)                     {                         max = side ? 2f * OuterRadius : 2f * OuterRadius - (OuterRadius - InnerRadius);                           min = side ? 0.5f * OuterRadius : 0.5f * OuterRadius - (OuterRadius - InnerRadius);                     }                     else                     {                         max = caps ? 2f * OuterRadius : 2f * OuterRadius - (OuterRadius - InnerRadius); ;                         min = caps ? 0.5f * OuterRadius : 0.5f * OuterRadius - (OuterRadius - InnerRadius);                     }                     //计算当前顶点到鼠标Y值之间的距离,再用余弦函数算出实际位移距离                     float dif = Mathf.Abs(info.point.y - transform.TransformPoint(_vertices[i]).y);                     if (Input.GetKey(KeyCode.RightArrow))                     {                         float outer = max - v_xz.magnitude;                         _vertices[i] += v_xz.normalized * Mathf.Min(0.01f * Mathf.Cos(((dif / 5 * Height) * Mathf.PI) / 2), outer);                     }                     else if (Input.GetKey(KeyCode.LeftArrow))                     {                         float inner = v_xz.magnitude - min;                         _vertices[i] -= v_xz.normalized * Mathf.Min(0.01f * Mathf.Cos(((dif / 5 * Height) * Mathf.PI) / 2), inner);                     }                       //Y轴变换                     float scale_y = transform.localScale.y;                     if (Input.GetKey(KeyCode.UpArrow))                     {                         scale_y = Mathf.Min(transform.localScale.y + 0.000001f, 2.0f);                     }                     else if (Input.GetKey(KeyCode.DownArrow))                     {                           scale_y = Mathf.Max(transform.localScale.y - 0.000001f, 0.3f);                     }                     transform.localScale = new Vector3(transform.localScale.x, scale_y, transform.localScale.z);                   }                   mesh.vertices = _vertices;                 mesh.RecalculateBounds();                 mesh.RecalculateNormals();                 meshFilter.mesh = mesh;                 meshCollider.sharedMesh = mesh;             }         }     } }   //计算时就把顶点坐标系转换为自身坐标系，求得向量后再转换为世界坐标系     Vector3 v_xz = transform.TransformDirection(transform.InverseTransformPoint(_vertices[i]) - transform.InverseTransformPoint(new Vector3(0, _vertices[i].y, 0)));   //3.法线平均化 IEnumerator Print_Normals()     {              for (int i = 0; i < meshFilter.mesh.vertices.Length; i++)         {                if (i % 2 == 0)             {                 Debug.DrawRay(transform.TransformPoint(meshFilter.mesh.vertices[i]), transform.TransformDirection(meshFilter.mesh.normals[i] * 0.3f), Color.green, 1000f);             }             else             {                 Debug.DrawRay(transform.TransformPoint(meshFilter.mesh.vertices[i]), transform.TransformDirection(meshFilter.mesh.normals[i] * 0.3f), Color.blue, 1000f);             }               yield return new WaitForSeconds(Time.deltaTime);           }     }   //回到项目上来。这段法线计算的代码就不放上来了，大致就是根据顶点在数组中的下标去判断位置是否相同，然后把该顶点的法线相加即可。大家自己构建Mesh时的顶点顺序可能会不太一样。 以上代码是否有问题，请帮我完善
最新发布
08-30
<think> 我们正在处理一个Unity项目，需要完善Mesh构建、动态改变形状和法线平均化的代码。 根据引用[1]和引用[2]： - 创建Mesh需要设置顶点、三角形、法线等。 - 法线信息是一个Vector3数组，每个顶点对应一个法线向量。 - 如果希望网格看起来平滑，需要对相邻面的法线进行平均（即平滑法线）。 - 引用[2]提到可以使用mesh.RecalculateNormals()自动计算法线，但它是根据相邻三角面计算平均法线，从而实现平滑效果。 然而，用户提到了“动态改变形状”和“法线平均化”，因此我们需要： 1. 动态更新Mesh的顶点（改变形状）。 2. 在顶点改变后，重新计算法线。我们可以使用RecalculateNormals()，但有时可能需要自定义法线计算（例如，实现特定的平均化方式）。 引用[2]中提到了一个偷懒的方法：mesh.RecalculateNormals()，它会自动计算每个顶点的法线（基于共享该顶点的所有三角面的法线平均值，并归一化）。 但如果我们想要自己计算法线（比如为了更精确的控制），则需要： - 首先计算每个三角面的法线（通过叉乘得到）。 - 然后对于每个顶点，收集所有共享该顶点的三角面的法线，求平均（并归一化）作为该顶点的法线。 考虑到动态改变形状，我们可能需要频繁更新法线，因此使用Unity内置的RecalculateNormals()可能是高效且方便的选择。但如果需要自定义（例如忽略某些面），则需要手动计算。 根据要求，我们提供两种方案： 方案1：使用Unity内置的RecalculateNormals()（简单，适用于一般平滑效果）。 方案2：手动计算平均法线（更灵活，但代码较多）。 我们先构建一个基本的Mesh构建类，包含： - 顶点数组（Vector3[] vertices） - 三角形数组（int[] triangles） - 法线数组（Vector3[] normals） - 初始化时构建网格并设置MeshFilter和MeshRenderer。 然后提供动态改变顶点的方法，并在改变后更新法线。 步骤： 1. 创建Mesh对象并设置顶点和三角形。 2. 计算法线（使用内置方法或自定义方法）。 3. 将网格应用于MeshFilter。 注意：动态改变形状时，我们可能会修改顶点数组，然后重新计算法线。 引用[3]提到法线对于渲染、照明等非常重要，所以正确设置法线很关键。 下面是一个示例类，包含： - 初始化网格（例如生成一个平面） - 修改顶点的方法 - 重新计算法线（可选择内置或自定义） 根据引用[2]，我们也可以选择手动计算法线。这里我们提供两种方式，并通过一个标志位选择。 注意：手动计算法线需要遍历三角形，计算每个面的法线，然后对每个顶点的所有相邻面的法线求平均。 由于用户要求动态改变形状，我们假设顶点位置会变化，但拓扑结构（三角形连接）不变？或者也可能改变？这里我们先假设三角形索引不变，只有顶点位置变化。 如果拓扑结构也动态改变，那么三角形数组也需要更新，但法线计算同理。 代码结构： ```csharp using UnityEngine; [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class DynamicMesh : MonoBehaviour { private Mesh mesh; private Vector3[] vertices; private int[] triangles; private Vector3[] normals; // 是否使用Unity内置的法线计算（否则使用自定义计算） public bool useUnityRecalculateNormals = true; void Start() { GetComponent<MeshFilter>().mesh = mesh = new Mesh(); mesh.name = "Dynamic Mesh"; // 初始化网格数据（例如创建一个平面） GenerateInitialMesh(); UpdateMesh(); } // 生成初始网格（示例：一个四边形平面） private void GenerateInitialMesh() { // 4个顶点 vertices = new Vector3[4]; vertices[0] = new Vector3(0, 0, 0); vertices[1] = new Vector3(1, 0, 0); vertices[2] = new Vector3(0, 1, 0); vertices[3] = new Vector3(1, 1, 0); // 两个三角形（顺时针或逆时针，注意Unity是顺时针为正面） triangles = new int[] { 0, 2, 1, 1, 2, 3 }; // 法线数组初始化为零，后面会计算 normals = new Vector3[4]; } // 更新网格（在修改顶点后调用） public void UpdateMesh() { mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; // 计算法线 if (useUnityRecalculateNormals) { mesh.RecalculateNormals(); // 从mesh中取回计算后的法线（如果我们后续需要访问） normals = mesh.normals; } else { normals = CalculateNormals(); mesh.normals = normals; } // 如果需要，也可以重新计算切线等 } // 自定义法线计算：计算每个顶点的法线（通过相邻面的平均） private Vector3[] CalculateNormals() { // 初始化法线数组（每个顶点一个法线，初始为Vector3.zero） Vector3[] vertexNormals = new Vector3[vertices.Length]; // 遍历每个三角形（每3个索引一个三角形） for (int i = 0; i < triangles.Length; i += 3) { int index0 = triangles[i]; int index1 = triangles[i + 1]; int index2 = triangles[i + 2]; Vector3 v0 = vertices[index0]; Vector3 v1 = vertices[index1]; Vector3 v2 = vertices[index2]; // 计算三角形面的法线（叉乘） Vector3 normal = Vector3.Cross(v1 - v0, v2 - v0).normalized; // 将这个面的法线加到三个顶点的法线上 vertexNormals[index0] += normal; vertexNormals[index1] += normal; vertexNormals[index2] += normal; } // 归一化每个顶点的法线（得到平均方向） for (int i = 0; i < vertexNormals.Length; i++) { vertexNormals[i] = vertexNormals[i].normalized; } return vertexNormals; } // 示例：动态改变顶点位置（例如根据噪声或物理模拟） public void ModifyVertices() { // 这里只是一个示例：随机移动顶点（实际应用中可能是更复杂的形变） for (int i = 0; i < vertices.Length; i++) { vertices[i] += Random.insideUnitSphere * 0.1f; } // 更新网格 UpdateMesh(); } // 在Inspector中提供一个按钮来测试修改顶点 [ContextMenu("Modify Vertices")] public void ModifyVerticesContextMenu() { ModifyVertices(); } } ``` 说明： - 在Start中，我们创建初始网格（一个平面四边形），然后调用UpdateMesh来设置网格并计算法线。 - 我们提供了两种计算法线的方式：使用Unity内置的RecalculateNormals（默认）或自定义的CalculateNormals方法（遍历三角形，计算每个面的法线并累加到顶点，然后归一化）。 - 动态修改顶点后，调用UpdateMesh更新网格和法线。 注意： - 自定义法线计算中，我们假设网格是连续的（即共享顶点）。如果网格中有不连续的顶点（例如硬边），那么需要特殊处理（比如复制顶点），但这里我们只考虑平滑网格。 - 内置的RecalculateNormals方法也会考虑顶点共享的情况，所以对于平滑网格，使用内置方法即可。 用户可以根据需求选择使用内置方法还是自定义方法。如果希望实现硬边（不平滑），可能需要不同的顶点法线（例如，在硬边处，同一个位置有多个顶点，每个顶点属于不同的面，法线不同）。 关于动态改变形状：这里只是简单示例（随机移动顶点），实际应用中可能是根据物理模拟、函数变形等。 请根据实际项目需求调整初始网格的生成和顶点修改逻辑。 参考引用： [^1]: 引用1说明需要提供法线数组，并提到平滑法线需要平均相邻面的法线。 [^2]: 引用2提到可以使用mesh.RecalculateNormals()自动计算法线，并解释了其原理（计算与顶点相连的三角面法线的平均值并归一化）。 [^3]: 引用3强调了法线在渲染和光照中的重要性。 完善点： - 我们实现了动态改变顶点后更新法线（内置方法或自定义方法）。 - 我们提供了自定义法线计算的代码，以便用户需要更精细控制时使用。 如果用户需要硬边（非平滑）的效果，则需要复制顶点（使每个三角形使用独立的顶点），然后为这些顶点分别设置法线（即三角形面的法线）。但这不是当前问题的重点。 因此，以上代码应该能够满足用户对动态改变形状和法线平均化的需求。 §§相关问题§§ 1. 在Unity中，如何为具有硬边的网格计算法线？ 2. 动态修改网格顶点时，如何优化性能？ 3. 除了法线，动态网格还需要更新哪些属性以保证正确渲染？ </think> 以下是针对 Unity 项目中 Mesh 构建、动态变形和法线平均化的代码检查与完善方案，整合了引用中的关键信息： ### 核心代码实现（含注释说明） ```csharp using UnityEngine; [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class DynamicMesh : MonoBehaviour { private Mesh mesh; private Vector3[] vertices; private Vector3[] normals; void Start() { // 初始化网格组件 GetComponent<MeshFilter>().mesh = mesh = new Mesh(); mesh.name = "Dynamic Mesh"; // 1. 基础网格构建（示例：平面） GenerateBaseMesh(); // 2. 动态更新顶点位置（示例：正弦波动） InvokeRepeating(nameof(UpdateShape), 0.1f, 0.1f); } // 生成基础网格（含UV和法线初始化） private void GenerateBaseMesh() { // 顶点设置（4个顶点构成平面） vertices = new Vector3[4] { new Vector3(0, 0, 0), new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0) }; // 三角形索引（两个三角面） int[] triangles = new int[6] { 0, 2, 1, // 第一个三角形 1, 2, 3 // 第二个三角形 }; // UV坐标（必须设置） Vector2[] uv = new Vector2[4] { new Vector2(0, 0), new Vector2(1, 0), new Vector2(0, 1), new Vector2(1, 1) }; mesh.vertices = vertices; mesh.triangles = triangles; mesh.uv = uv; // 3. 法线计算（平滑平均） CalculateSmoothNormals(); // 使用自定义平滑法线 // mesh.RecalculateNormals(); // 或使用Unity内置方法[^2] } //=== 关键完善点1：平滑法线计算 === private void CalculateSmoothNormals() { // 初始化法线数组（与顶点一一对应）[^1] normals = new Vector3[vertices.Length]; // 步骤1：计算每个三角面的法线 Vector3[] faceNormals = new Vector3[mesh.triangles.Length / 3]; for (int i = 0; i < mesh.triangles.Length; i += 3) { int idx0 = mesh.triangles[i]; int idx1 = mesh.triangles[i + 1]; int idx2 = mesh.triangles[i + 2]; Vector3 v1 = vertices[idx1] - vertices[idx0]; Vector3 v2 = vertices[idx2] - vertices[idx0]; faceNormals[i / 3] = Vector3.Cross(v1, v2).normalized; } // 步骤2：顶点法线平均化[^1] for (int i = 0; i < vertices.Length; i++) { Vector3 normalSum = Vector3.zero; int count = 0; // 遍历所有三角形，找到共享当前顶点的面 for (int j = 0; j < mesh.triangles.Length; j++) { if (mesh.triangles[j] == i) { int faceIndex = j / 3; normalSum += faceNormals[faceIndex]; count++; } } // 计算平均值并单位化[^3] normals[i] = (count > 0) ? (normalSum / count).normalized : Vector3.up; } mesh.normals = normals; // 应用法线 } //=== 关键完善点2：动态改变形状 === private void UpdateShape() { // 动态修改顶点位置（示例：Y轴正弦波动） for (int i = 0; i < vertices.Length; i++) { float wave = Mathf.Sin(Time.time + i * 0.5f); vertices[i].y = wave * 0.2f; // 振幅控制 } mesh.vertices = vertices; // 更新顶点 mesh.RecalculateBounds(); // 重计算边界 // 动态更新法线（必须执行！） CalculateSmoothNormals(); // 若使用内置方法：mesh.RecalculateNormals()[^2] } } ``` ### 关键完善说明 1. **法线平均化优化** - 手动实现相邻面法线加权平均（`CalculateSmoothNormals`方法） - 替代方案：直接调用 `mesh.RecalculateNormals()`（Unity 内置的面法线平均算法）[^2] - **注意**：两种方法都要求顶点位置更新后**必须重新计算法线**，否则光照错误 2. **动态变形要点** - 修改 `vertices` 数组后需重新赋值给 `mesh.vertices` - 必须调用 `RecalculateBounds()` 更新碰撞检测范围 - UV 坐标在初始化后无需修改（除非做纹理动画） 3. **性能优化** ```csharp // 在UpdateShape()开头添加（减少GC） mesh.MarkDynamic(); // 声明为动态网格[^2] // 避免每帧创建新数组 vertices = mesh.vertices; // 直接获取引用 ``` 4. **探针与光照兼容** ```csharp // 确保MeshRenderer正确响应光照 GetComponent<MeshRenderer>().lightProbeUsage = LightProbeUsage.BlendProbes; GetComponent<MeshRenderer>().reflectionProbeUsage = ReflectionProbeUsage.BlendProbes; ``` ### 验证要点 1. **法线方向验证** - 在Scene视图开启 **Face Culling**，确认法线朝向一致 - 使用Debug.DrawRay绘制顶点法线辅助检查 2. **平滑度测试** - 对比 `mesh.RecalculateNormals()` 和自定义算法的平滑效果 - 硬边处理需分割顶点（非平均法线） > 引用说明：[^1] 手动计算法线需顶点与法线一一对应；[^2] `RecalculateNormals()` 使用面法线平均值；[^3] 单位化法线保证光照计算正确。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值