unity面试八股文 - 基础篇

委托是什么? event 关键字有什么用?

委托
委托是一种特殊类型的对象,它包含了对一个方法的引用。简单来说,委托就像是一个安全的函数指针。它允许我们创建可在运行时动态更改其引用方法的变量,并且可以指向类中定义的任何具有相同签名(即参数类型和返回类型)的方法。

Event
"Event"关键字在C#或其他面向对象编程语言中常被使用, 它主要用于发布/订阅模式(也称为观察者模式)。当某个重要事件(比如点击按钮、文件下载完成等)发生时,程序需要通知其他部分进行相应处理。这时候就会使用到"Event"关键字来声明事件,并通过调用这个事件来通知所有订阅了该事件(即注册了该事件处理器)的代码块。

Unity协程是如何实现的

Unity中的协程是一种特殊类型的函数,可以在给定的时间段内多次返回。它们在某些情况下非常有用,比如当你需要对一个操作进行计时或者延迟执行。

以下是Unity协程实现的基本步骤:

创建协程函数:首先,你需要创建一个返回IEnumerator接口类型的函数。这个接口允许你控制代码何时暂停和恢复。

IEnumerator MyCoroutine()
{
    // 这里写入你想要执行的代码
    yield return null; // 暂停并在下一帧继续
}

启动协程:使用StartCoroutine()方法启动定义好的协程。

StartCoroutine(MyCoroutine());

控制流:通过yield关键字来控制代码执行流。例如:

  • yield return null:暂停当前帧,并在下一帧恢复。
  • yield return new WaitForSeconds(1):暂停1秒后恢复。
  • yield return StartCoroutine(“AnotherCoroutine”):
    开始另一个协程,并等待它完成后再继续。
    以上就是Unity中实现和使用协程的基本方式。请注意,虽然看起来像多线程编程,但实际上所有Unity API调用都必须在主线程上完成,因此不会遇到常规多线程序可能遇到的并发问题。

摄像机有几种模式,成像原理分别是什么?

摄像机(Camera)有三种模式:正交投影模式(Orthographic)、透视投影模式(Perspective)和物理相机(Physical Camera)。

  • 正交投影模式:
    在这种模式下,摄像机将场景以平行线方式进行投影。这种方式没有透视效果,即远离或靠近摄像头的物体大小不会改变。这种模式通常用于2D游戏或者需要特殊视觉效果的3D游戏。

  • 透视投影模式:
    在此设置下,摄像机将场景以收敛线方式进行投影。也就是说,远离镜头的物体会显得更小。这就产生了一种深度感或者三维空间感觉,使得画面看起来更加真实立体。

  • 物理相机:
    从Unity 2018版本开始引入了"Physical Camera"属性, 可以让你设置镜头、传感器和其他一些参数, 更接近现实世界中相机的工作原理.

在Unity中,“成像原理”主要依赖于渲染管线(Render Pipeline)来完成。当你启动一个Scene时, Unity首先创建一个包含所有对象数据(位置、纹理、光照等)的渲染队列(Render Queue), 然后通过Shader程序对每个物体进行处理并生成图形数据, 最后由GPU根据这些数据生成最终图像并显示到屏幕上.

Canvas 有几种模式,如何配置?

Canvas是用于布局和渲染所有UI元素的组件。它有三种模式:

  • 世界空间(World Space):在这种模式下,Canvas表现为任何常规的3D对象一样。你可以自由地移动、旋转、缩放它。这种模式通常用于3D游戏中的交互UI或者VR应用。

  • 屏幕空间-覆盖(Screen Space - Overlay):这是默认的Canvas模式。在此模式下,Canvas将覆盖屏幕,并始终对准摄像机视野的前方,无论摄像机如何移动或旋转。当你需要全屏显示UI元素时,比如菜单、得分板等,这个选项非常实用。

  • 屏幕空间-相机(Screen Space - Camera):此模式将Canvas渲染到特定摄像头的平面上,并随着摄像头移动而变化位置和大小。

UGUI如何打包图集

在Unity 2018及以后的版本中,Unity引入了新的系统"Sprite Atlas"来替代旧的"Sprite Packer"。以下是使用新版Sprite Atlas打包图集的步骤:

在Project窗口中右键点击 -> Create -> Sprite Atlas,创建一个新的Sprite Atlas对象。

将所有需要打包成图集的图片拖动到这个新建立的Sprite Atlas对象上,在Inspector窗口中可以看到Objects for Packing区域,里面列出了你添加进来的所有图片。

在Inspector窗口可以看到Pack Preview按钮, 点击它可以预览打包效果。如果满意,则可以保存并关闭预览。

在编写脚本或者配置UI元素时引用这些Sprite时, Unity会自动使用它们在图集中对应部分, 而不再是单独加载原始小图片。

如果你想要手动控制何时进行打包操作,也可以通过编程方式调用UnityEditor.U2D.SpriteAtlasUtility.PackAtlases()函数进行手动打包。注意这个函数只能在编辑器环境下使用,并且需要添加#if UNITY_EDITOR和#endif标记防止在构建游戏时产生错误。

UGUI 如何实现UI物体淡入淡出

在Unity的UGUI系统中,实现UI物体的淡入淡出效果可以通过调整Canvas Group组件或者Image和Text组件自身的Alpha值来达到。这里以Canvas Group为例,演示如何使用C#脚本实现:

首先,在你想要进行淡入淡出操作的UI物体上添加一个Canvas Group组件。

然后创建一个新的C#脚本,例如命名为FadeInOut,并把以下代码粘贴进去:

using System.Collections;
using UnityEngine;
using UnityEngine.UI;

public class FadeInOut : MonoBehaviour
{
    public float fadeSpeed = 0.5f; // 控制淡入淡出速度

    private CanvasGroup canvasGroup;

    void Start()
    {
        canvasGroup = GetComponent<CanvasGroup>();
        StartCoroutine(FadeIn());
    }

    IEnumerator FadeIn()
    {
        while (canvasGroup.alpha < 1)
        {
            canvasGroup.alpha += Time.deltaTime * fadeSpeed;
            yield return null;
        }
        
        yield return new WaitForSeconds(2); // 淡入完成后等待两秒开始执行淡出
        
        StartCoroutine(FadeOut());
    }

     IEnumerator FadeOut()
     {
         while (canvasGroup.alpha > 0)
         {
             canvasGroup.alpha -= Time.deltaTime * fadeSpeed;
             yield return null;
         }
     }
}

最后,将这个脚本附加到你刚才添加了Canvas Group组件的UI物体上,并设置好fadeSpeed参数即可。

运行游戏时,该UI物体就会以指定速度进行一次完整的从完全透明(alpha=0)到完全不透明(alpha=1)再回到完全透明(alpha=0)的过程。如果你需要在特定事件触发时进行此效果,则需要稍微修改以上代码结构来满足需求。

Hash表的原理是什么, 如何实现

哈希表(HashTable)也被称为散列表,是一种数据结构,它提供了快速插入、删除和查找操作的功能。哈希表通过使用哈希函数将键(Key)映射到存储位置,然后在这个位置存储值(Value)。

这是一个简单的示例来解释它是如何工作的:

假设我们有一个空的哈希表,并且我们想要在其中添加一个元素,例如(“name”, “John”)。
我们首先将键(“name”)输入到哈希函数中。这个函数会返回一个数字(假设返回3),我们把值(“John”)存储在数组索引为3的位置上。
当我们想要查找键为"name"对应的值时,我们再次使用同样的哈希函数处理键(“name”),得到相同的数字(3),然后直接访问数组索引为3处获取其对应值即可。
实现基本步骤如下:

  • 初始化:
    创建一个足够大容量(通常大于预期元素数量)且初始全部为空或特定标记值(例如null) 的数组用于存放数据。

  • 插入:
    当需要插入新元素时, 先通过hash 函数计算出该元素key 对应 hashcode, 然后根据 hashcode 找到在数组中对应下标位置并将value 存放进去.

  • 查找:
    当需要查找某个key 对应value 时, 同样先计算出该key 对应hashcode, 再根据hashcode 找到对应下标并读取value.

  • 删除:
    删除则与查找类似, 先定位到具体位置然后再进行删除操作.

不过需要注意,在实际情况中可能会发生所谓“碰撞”现象——即两个不同Key经过Hash Function计算得出相同HashCode导致他们试图占用同一块内存地址。
解决碰撞问题主要有两种方法:“开放寻址法”和“链地址法”。

  • 开放寻址法就是如果发生碰撞,则向前或向后探测其他空位;
  • 链地址法则是每个Hash槽里面维护了一个链表或者其他数据结构,在碰撞时就把Value添加进对应槽位里面去。

实际使用中还需要考虑扩容、缩容、哈希函数设计等问题。

链表如何实现

链表是一种动态数据结构,它使用节点(Node)来存储数据。每个节点包含两个部分:一个是数据域,用于保存数据;另一个是指针域,用于链接到下一个节点。这种结构使得在任何位置插入或删除元素都变得相对容易。

在C#中,链表的实现相对简单,因为它提供了内建的LinkedList类。但是如果你想自己实现一个链表,那么可以按照以下步骤操作:

定义节点(Node)类:


public class Node
{
    public int Data { get; set; }
    public Node Next { get; set; }

    public Node(int data)
    {
        this.Data = data;
        this.Next = null;
    }
}

定义链表(LinkedList)类,并实现添加(add)、删除(delete)等方法:

public class LinkedList
{
    private Node head;

    public LinkedList()
    {
        this.head = null;
    }

    // 添加节点到链表尾部
    public void AddLast(int data)
    {
        Node newNode = new Node(data);

        if (head == null)
            head = newNode;
        else
        {
            Node current = head;

            while (current.Next != null)
                current = current.Next;

            current.Next = newNode;
        }
        
    }

   // 删除特定值的节点(假设值唯一)
    public void DeleteNode(int key)
   {
       // 如果头结点就是要删除的结点 
       if(head != null && head.Data == key)
       {
           head= head.Next;
           return ;
       }

       // 其他情况,找到要删除结点前面一个结点prev和要删除结点current 
      Node prev=null, current=head ;
      while(current!=null && current.Data!=key){
          prev=current ;
          current=current.Next ;
      } 

     // 如果找不到这样的结点,则返回 
     if(current==null)return ;

     // 跳过当前要删除的节点 
     prev.next=current.next ;   

   }
}

Unity节点缓存池如何实现

在Unity中,对象池(Object Pool)是一种常用的优化技术,可以减少实例化和销毁对象的开销。以下是一个简单的Unity节点缓存池实现:

首先,创建一个新的C#脚本并命名为ObjectPooler,然后添加以下代码:


using System.Collections.Generic;
using UnityEngine;

public class ObjectPooler : MonoBehaviour
{
    public static ObjectPooler Instance;

    public GameObject pooledObject;
    public int pooledAmount = 20;
    public bool willGrow = true;

    List<GameObject> pooledObjects;

    void Awake()
    {
        Instance = this;
    }

    void Start ()
    {
        pooledObjects = new List<GameObject>();
        for (int i = 0; i < pooledAmount; i++)
        {
            GameObject obj = (GameObject)Instantiate(pooledObject);
            obj.SetActive(false);
            pooledObjects.Add(obj);
        }
    }

    public GameObject GetPooledObject()
    {
        for (int i=0; i<pooledObjects.Count; i++)
        {
            if (!pooledObjects[i].activeInHierarchy)
            {
                return pooledObjects[i];
            }
        }

        if (willGrow)
        {
            GameObject obj = (GameObject)Instantiate(pooledObject);
            obj.SetActive(false);
            pooledObjects.Add(obj);
            return obj;
        }
        
        return null;
   }
}

这个脚本会创建并管理一个指定类型的游戏对象(GameObject)列表。它首先预加载一定数量(pooledAmount)的游戏对象,并将它们设置为非激活状态。当你需要从池中获取一个对象时,它会遍历列表并返回第一个非激活状态的对象。

如果所有对象都处于激活状态,并且willGrow属性设置为true,则该脚本将实例化一个新的游戏对象,并添加到列表中。

注意:在使用时,请确保已经把要生成物体预制体拖入到pooledObject位置上,并且在使用完物体后记得把物体设为非激活状态以便再次使用。

更复杂的
对于复制一点的需求,你可能是想要创建一个能够存储和管理多种类型游戏对象的对象池。这可以通过在我们先前示例的基础上进行扩展来实现。

首先,我们需要创建一个新的类来存储每种类型游戏对象的信息:


[System.Serializable]
public class ObjectPoolItem
{
    public GameObject objectToPool;
    public int amountToPool;
    public bool shouldExpand = true;
}

然后,在ObjectPooler类中使用这个新类:


public class ObjectPooler : MonoBehaviour 
{
    public static ObjectPooler SharedInstance;
    
    //新增:用于存储不同类型游戏对象信息的列表
    public List<ObjectPoolItem> itemsToPool;

    //新增:用于存储所有已经实例化出来的游戏对象列表
    public List<GameObject> pooledObjects;

    void Awake()
    {
        SharedInstance = this;
    }

    void Start () 
    {
        pooledObjects = new List<GameObject>();
        
        foreach (ObjectPoolItem item in itemsToPool)
        {
            for (int i = 0; i < item.amountToPool; i++)
            {
                GameObject obj = (GameObject)Instantiate(item.objectToPool);
                obj.SetActive(false);
                pooledObjects.Add(obj);
            }
        }
    }

    public GameObject GetPooledObject(string tag)
    {
        for (int i=0; i<pooledObjects.Count; i++)
        {
            if (!pooledObjects[i].activeInHierarchy && pooledObjects[i].tag == tag)
            {
                return pooledObjects[i];
            }
        }

        foreach(ObjectPoolItem item in itemsTopool){
            if(item.objectTopool.tag == tag){
                if(item.shouldExpand){
                    GameObject obj=(GameObject)Instantiate(item.objectTopool);
                    obj.SetActive(false);
                    poolobjects.Add(obj);
                    return obj;
                }
            }
        }

        return null;
   }	
}

在此版本中,你可以通过Unity编辑器为每种类型游戏对象指定预设、数量以及是否允许扩展。当需要获取一个特定标签(tag)的游戏对象时,只需调用GetPooledObject()函数并传入相应标签即可。

注意:请确保预设物体都有正确设置tag, 并且在使用完物体后记得把物体设为非激活状态以便再次使用。

Unity如何实现单例模式

在Unity中实现单例模式可以通过创建一个静态实例的脚本类来完成。这个类将始终返回同一个对象的引用,如果该对象没有被创建,那么它就会创建一个。

以下是在Unity中实现单例模式的一种常见方法:

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T _instance;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (_instance == null)
                {
                    GameObject singleton = new GameObject();
                    _instance = singleton.AddComponent<T>();
                    singleton.name = typeof(T).ToString() + " (Singleton)";
                    
                    // 确保单例不会被销毁
                    DontDestroyOnLoad(singleton);
                }
            }

            return _instance;
        }
    }
}

你可以通过继承这个Singleton类来创建自己的单例类。例如:


public class MySingletonClass : Singleton<MySingletonClass>
{
   // 这里是你自己的代码...
}

然后,你就可以通过MySingletonClass.Instance来访问这个单例对象了。

注意:虽然使用单例模式很方便,但也需要谨慎对待。过度使用可能导致代码难以理解和维护,并可能引发难以调试的问题。只有当你确信某个特定组件真正需要全局访问时,才应该使用此模式。

[MenuItem] 什么意思

在Unity中,[MenuItem]是一个特性(Attribute),它用于在Unity的菜单栏中创建新的菜单项。这个特性可以应用于静态方法。

例如,你可能会使用以下代码来添加一个名为"Custom/My Function"的新菜单项:


using UnityEngine;
using UnityEditor;

public class MyEditorScript 
{
    [MenuItem("Custom/My Function")]
    static void MyFunction() 
    {
        // 这里是你自定义功能的代码...
        Debug.Log("My Function Was Called!");
    }
}

当你点击"Custom/My Function"这个菜单项时,就会执行MyFunction()方法,并在控制台打印出"My Function Was Called!"。

注意:因为[MenuItem]特性只能应用于静态方法,所以被标记为菜单项的函数必须是静态的。此外,这个特性只能用在编辑器脚本中,也就是说包含该函数的类必须放置在项目文件夹下名为 “Editor” 的文件夹内。

打包ab包出来后.manifest有什么作用

在Unity中,AssetBundle文件的".manifest"文件包含了一些关于AssetBundle的元数据,包括其依赖项和散列值。这些信息主要用于加载和缓存AssetBundles。

  • 依赖项:
    当你从一个AssetBundle加载资源时,可能需要先加载其他的AssetBundles。这是因为资源可能引用了其他AssetBundles中的资源(例如材质、纹理等)。".manifest"文件会列出所有必须首先加载的依赖项。

  • 散列值:
    散列值用于检查缓存中是否存在最新版本的AssetBundle。当你尝试从服务器下载一个已经在本地缓存过的AssetBundle时,Unity会比较本地版本和服务器上版本的散列值。如果两者相同,则Unity会直接从缓存中加载该bundle,而不是重新下载。

所以说,在处理.manifest文件时需要特别注意其作用和重要性。正确处理它们可以确保游戏正常运行,并有效利用玩家设备上的存储空间。

Image与RawImage的区别

在Unity的UI系统中,Image和RawImage都是用于显示图像的组件,但它们之间有一些关键区别:

Image
这个组件使用Sprite作为其图像源。它支持各种类型的填充方法(例如简单填充、水平或垂直填充、径向360度等),可以使用九宫格布局来处理图像边缘,并且支持颜色渐变。此外,你还可以在Image上应用遮罩。

RawImage:
这个组件使用Texture作为其图像源。它不支持填充方法、九宫格布局或者遮罩等特性。但是,由于直接引用纹理数据,所以Raw Image更适合显示不需要以上特性,并且希望直接访问原始纹理数据的情况(例如WebCamTexture或者RenderTexture)。

总结
如果你需要更多控制和复杂的渲染选项(如颜色渐变, 填充, 遮罩等), 使用 Image. 如果你只是想简单地展示一个纹理并且不需要额外功能, 或者你正在处理不能转换为 Sprite 的纹理类型(例如WebCamTexture或RenderTexture)时,那么选择 Raw Image.

Unity有哪些特定的文件夹名字,有什么作用

在Unity项目中,有一些特定的文件夹名称具有特殊的含义和作用:

  • Assets:这是所有Unity项目的根目录,所有的脚本、场景、预设、音频和图像等资源都应该放在这个文件夹或其子文件夹中。

  • Editor:这个文件夹用于存放编辑器脚本,即那些只在Unity编辑器中运行并扩展其功能的脚本。例如自定义Inspector面板、菜单项等。

  • Resources:你可以将需要使用到Resources.Load()方法动态加载的资源放入此文件夹。注意不要过度使用此类加载方式,因为它可能会增加应用程序启动时间,并使内存管理更复杂。

  • StreamingAssets:这个目录下的所有内容都会被原封不动地拷贝到最终构建结果中。你可以用来存储如文本文件、数据库或者已经压缩好了格式无法再进行进一步优化处理的数据(比如视频)。

  • Gizmos: 这个目录主要是用来存储自定义Gizmo图标,在Scene视图里面显示出来帮助开发者定位对象和理解场景布局。

  • Plugins: 这个目录主要是用来存储插件,包括各种第三方库, 如Android .jar/.aar 文件, iOS静态库.a 文件等.

注意: 使用以上特殊名称创建新目录时,请确保大小写正确,并且直接将其创建在正确位置上。否则Unity可能无法识别该目录并提供相应功能。

Unity如何实现游戏截图

针对去屏幕截图
在Unity中,你可以使用ScreenCapture.CaptureScreenshot()方法来实现游戏截图。以下是一个简单的例子:

csharp
复制
using UnityEngine;

public class ScreenshotTaker : MonoBehaviour
{
public void TakeScreenshot()
{
// 生成文件名(以当前时间命名)
string fileName = “Screenshot_” + System.DateTime.Now.ToString(“yyyy-MM-dd_HH-mm-ss”) + “.png”;

    // 在游戏的数据路径下创建 Screenshots 文件夹(如果不存在)
    string directoryPath = Application.persistentDataPath + "/Screenshots/";
    if (!System.IO.Directory.Exists(directoryPath))
        System.IO.Directory.CreateDirectory(directoryPath);
    
    // 捕获屏幕并保存为 .png 文件
    ScreenCapture.CaptureScreenshot(directoryPath + fileName);
    
    Debug.Log("Screenshot saved to: " + directoryPath + fileName);
}

}
然后,你可以将这个脚本添加到场景中的任何GameObject上,并通过代码或者按钮点击等方式调用TakeScreenshot()方法。

注意:ScreenCapture.CaptureScreenshot()方法会在下一帧捕获屏幕,因此如果你立即查找文件可能不会找到它。

针对于特定摄像机或者区域进行截图
使用RenderTexture和Texture2D.ReadPixels()方法。
以下是一个简单的例子:


using UnityEngine;

public class CameraScreenshotTaker : MonoBehaviour
{
    public Camera screenshotCamera; // 截图用的摄像机

    public void TakeScreenshot(int width, int height)
    {
        // 创建一个新的RenderTexture
        RenderTexture renderTex = new RenderTexture(width, height, 24);
        
        // 让截图用的摄像机渲染到新建立的RenderTexture上
        screenshotCamera.targetTexture = renderTex;
        
        // 创建一个空纹理并读取屏幕内容到这个纹理中
        Texture2D screenShot = new Texture2D(width, height, TextureFormat.RGB24, false);
        
        screenshotCamera.Render();
        
        RenderTexture.active = renderTex;
        
        screenShot.ReadPixels(new Rect(0, 0, width,height), 0 ,0);
       
        screenShot.Apply();

        byte[] bytes=screenShot.EncodeToPNG();
        
        string filename=Application.dataPath + "/Screenshot.png";
        
        System.IO.File.WriteAllBytes(filename, bytes);

        Debug.Log(string.Format("截屏了一张照片: {0}", filename));
 
        // 恢复环境,释放申请的资源。
        screenshotCamera.targetTexture=null;
        RenderTexture.active=null; 
        GameObject.Destroy(renderTex);	
    }
}

在这个脚本中,我们首先创建了一个新的RenderTexture对象,并将其设置为我们希望进行截图操作的摄像机目标纹理。然后,我们让该摄像机渲染一次,并使用ReadPixels()方法从当前激活(active)状态下得 RenderTexturereadPixels()读取所有像素信息。

之后就可以将这些数据保存为图片文件了。记住在完成所有操作后恢复环境并释放资源。

注意:以上代码只能在Unity主线程中运行,不能在另外线程中执行。

Unity如何调用android与iOS的 API函数

在Unity中调用Android和iOS的API,你需要使用Unity的插件功能。下面是一些基本步骤:

对于Android:

首先,你需要使用Java(或Kotlin)创建一个Android库(.jar或.aar文件),并在此库中定义你想要调用的函数。
然后,在Unity项目的Assets/Plugins/Android目录下放置这个库文件。
在C#脚本中,使用AndroidJavaObject 或 AndroidJavaClass来调用这个库里面的函数。
例如:


using UnityEngine;

public class AndroidPluginTest : MonoBehaviour
{
    void Start()
    {
        if (Application.platform == RuntimePlatform.Android)
        {
            AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");

            // Assuming the plugin class name is "com.example.myplugin.MyPlugin"
            // and it has a static method "foo"
            using (var pluginClass = new AndroidJavaClass("com.example.myplugin.MyPlugin"))
                pluginClass.CallStatic("foo", currentActivity);
        }
    }
}

对于iOS:

你需要创建一个Objective-C(或Swift但会更复杂)类,并在其中定义你想要调用的函数。
将该类保存为.mm文件,并放入到Assets/Plugins/iOS目录下。
Unity将自动将这些类编译到生成的Xcode项目中。然后,在C#脚本中可以直接通过PInvoke机制来访问它们。
例如:

using System.Runtime.InteropServices;
using UnityEngine;

public class iOSPluginTest : MonoBehaviour
{
#if UNITY_IOS && !UNITY_EDITOR
    [DllImport("__Internal")]
    private static extern void _Foo();
#endif

    public void CallFoo()
    {
#if UNITY_IOS && !UNITY_EDITOR
        _Foo();
#endif
    }
}

以上代码假设您有一个名为_Foo() 的Objective-C方法。

注意:确保当平台不匹配时正确处理平台相关代码,以防止在其他平台上产生编译错误。

你可能感兴趣的:(面试八股文,Unity,C#,unity,面试,游戏引擎)