Unity 中的反射使用详解

原创 于 2025-12-15 10:14:18 发布 · 412 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#unity #游戏引擎 #c# #游戏开发

1. Unity 中反射的特殊性

Unity 中的反射使用与标准 C# 基本相同，但需要注意以下特殊点：

1.1 Unity 对象特殊处理

csharp

// MonoBehaviour 的特殊性
public class Player : MonoBehaviour
{
    public int health = 100;
    private string playerName = "Hero";
    
    public void TakeDamage(int amount)
    {
        health -= amount;
    }
    
    private void OnDestroy()
    {
        // Unity 生命周期方法
    }
}

// 获取 MonoBehaviour 类型
Type playerType = typeof(Player);

// Unity 特定的特性
[System.Serializable]
public class Item
{
    public string name;
    public int value;
}

1.2 Unity 编辑器和运行时反射

csharp

#if UNITY_EDITOR
using UnityEditor;
#endif

public class ReflectionExamples : MonoBehaviour
{
    // Unity Editor 中的反射使用
#if UNITY_EDITOR
    [MenuItem("Tools/List Components")]
    public static void ListAllComponents()
    {
        GameObject[] allObjects = GameObject.FindObjectsOfType<GameObject>();
        foreach (GameObject go in allObjects)
        {
            Component[] components = go.GetComponents<Component>();
            foreach (Component comp in components)
            {
                Debug.Log($"Object: {go.name}, Component: {comp.GetType().Name}");
            }
        }
    }
#endif
}

2. Unity 中常见的反射应用场景

2.1 动态获取和设置组件属性

csharp

public class ComponentReflector : MonoBehaviour
{
    public GameObject targetObject;
    public string componentTypeName = "Rigidbody";
    public string propertyName = "mass";
    public float newValue = 2.0f;
    
    void Start()
    {
        if (targetObject == null) return;
        
        // 动态获取组件
        Type componentType = Type.GetType($"UnityEngine.{componentTypeName}, UnityEngine");
        if (componentType != null)
        {
            Component component = targetObject.GetComponent(componentType);
            if (component != null)
            {
                // 获取属性信息
                PropertyInfo property = componentType.GetProperty(propertyName);
                if (property != null && property.CanWrite)
                {
                    // 获取当前值
                    object currentValue = property.GetValue(component);
                    Debug.Log($"Current {propertyName}: {currentValue}");
                    
                    // 设置新值
                    property.SetValue(component, newValue);
                    Debug.Log($"Set {propertyName} to: {newValue}");
                }
                else
                {
                    Debug.LogError($"Property '{propertyName}' not found or read-only");
                }
            }
        }
    }
}

2.2 查找带有特定特性的组件

csharp

// 自定义特性
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public class ExposeInEditorAttribute : Attribute
{
    public string DisplayName { get; private set; }
    
    public ExposeInEditorAttribute(string displayName = null)
    {
        DisplayName = displayName;
    }
}

// 使用特性的组件
public class ConfigurableObject : MonoBehaviour
{
    [ExposeInEditor("移动速度")]
    public float moveSpeed = 5.0f;
    
    [ExposeInEditor("跳跃高度")]
    public float jumpHeight = 2.0f;
    
    [SerializeField, ExposeInEditor("血量")]
    private int health = 100;
    
    // 普通字段，不会被暴露
    public float rotationSpeed = 90.0f;
}

// 反射查找带有特性的字段
public class AttributeFinder : MonoBehaviour
{
    void Start()
    {
        ConfigurableObject obj = GetComponent<ConfigurableObject>();
        if (obj == null) return;
        
        Type type = typeof(ConfigurableObject);
        
        // 查找所有字段
        FieldInfo[] fields = type.GetFields(
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        
        foreach (FieldInfo field in fields)
        {
            // 检查是否有 ExposeInEditorAttribute
            ExposeInEditorAttribute attribute = 
                field.GetCustomAttribute<ExposeInEditorAttribute>();
            
            if (attribute != null)
            {
                string displayName = string.IsNullOrEmpty(attribute.DisplayName) 
                    ? field.Name 
                    : attribute.DisplayName;
                
                object value = field.GetValue(obj);
                Debug.Log($"{displayName}: {value}");
            }
        }
        
        // 也可以查找属性
        PropertyInfo[] properties = type.GetProperties(
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        
        foreach (PropertyInfo property in properties)
        {
            ExposeInEditorAttribute attribute = 
                property.GetCustomAttribute<ExposeInEditorAttribute>();
            
            if (attribute != null)
            {
                string displayName = string.IsNullOrEmpty(attribute.DisplayName) 
                    ? property.Name 
                    : attribute.DisplayName;
                
                object value = property.GetValue(obj);
                Debug.Log($"{displayName}: {value}");
            }
        }
    }
}

2.3 动态添加组件和执行方法

csharp

public class DynamicComponentManager : MonoBehaviour
{
    public void AddComponentDynamically(string componentName)
    {
        // 构建完整的类型名称
        string fullTypeName = componentName;
        if (!fullTypeName.Contains("UnityEngine"))
        {
            // 尝试从当前程序集查找
            fullTypeName = $"{componentName}, Assembly-CSharp";
        }
        
        Type componentType = Type.GetType(fullTypeName);
        if (componentType != null && 
            typeof(Component).IsAssignableFrom(componentType))
        {
            gameObject.AddComponent(componentType);
            Debug.Log($"Added component: {componentType.Name}");
        }
        else
        {
            Debug.LogError($"Cannot find component type: {componentName}");
        }
    }
    
    public void InvokeMethodDynamically(string methodName, object parameter = null)
    {
        MonoBehaviour[] components = GetComponents<MonoBehaviour>();
        
        foreach (MonoBehaviour component in components)
        {
            Type type = component.GetType();
            MethodInfo method = null;
            
            // 尝试查找方法
            if (parameter == null)
            {
                method = type.GetMethod(methodName, Type.EmptyTypes);
                if (method != null)
                {
                    method.Invoke(component, null);
                    return;
                }
            }
            else
            {
                // 查找带参数的方法
                MethodInfo[] methods = type.GetMethods();
                foreach (MethodInfo m in methods)
                {
                    if (m.Name == methodName && 
                        m.GetParameters().Length == 1 &&
                        m.GetParameters()[0].ParameterType == parameter.GetType())
                    {
                        m.Invoke(component, new object[] { parameter });
                        return;
                    }
                }
            }
        }
        
        Debug.LogWarning($"Method {methodName} not found on any component");
    }
}

2.4 序列化和反序列化系统

csharp

using System.Collections.Generic;
using UnityEngine;

[System.Serializable]
public class GameData
{
    public string playerName;
    public int level;
    public float experience;
    public List<string> inventory;
}

public class ReflectionSerializer : MonoBehaviour
{
    public GameData gameData;
    
    // 使用反射将对象转换为字典
    public Dictionary<string, object> ObjectToDictionary(object obj)
    {
        Dictionary<string, object> dict = new Dictionary<string, object>();
        
        Type type = obj.GetType();
        FieldInfo[] fields = type.GetFields(
            BindingFlags.Public | BindingFlags.Instance);
        
        foreach (FieldInfo field in fields)
        {
            object value = field.GetValue(obj);
            dict[field.Name] = value;
        }
        
        PropertyInfo[] properties = type.GetProperties(
            BindingFlags.Public | BindingFlags.Instance);
        
        foreach (PropertyInfo property in properties)
        {
            if (property.CanRead)
            {
                object value = property.GetValue(obj);
                dict[property.Name] = value;
            }
        }
        
        return dict;
    }
    
    // 从字典恢复对象
    public T DictionaryToObject<T>(Dictionary<string, object> dict) where T : new()
    {
        T obj = new T();
        Type type = typeof(T);
        
        foreach (var kvp in dict)
        {
            FieldInfo field = type.GetField(kvp.Key);
            if (field != null && field.FieldType == kvp.Value.GetType())
            {
                field.SetValue(obj, kvp.Value);
                continue;
            }
            
            PropertyInfo property = type.GetProperty(kvp.Key);
            if (property != null && property.CanWrite && 
                property.PropertyType == kvp.Value.GetType())
            {
                property.SetValue(obj, kvp.Value);
            }
        }
        
        return obj;
    }
}

3. Unity 中的性能优化技巧

3.1 缓存反射结果

csharp

public class ReflectionCacheManager : MonoBehaviour
{
    private static Dictionary<string, FieldInfo> fieldCache = new Dictionary<string, FieldInfo>();
    private static Dictionary<string, MethodInfo> methodCache = new Dictionary<string, MethodInfo>();
    
    public static FieldInfo GetCachedField(Type type, string fieldName)
    {
        string key = $"{type.FullName}.{fieldName}";
        
        if (!fieldCache.ContainsKey(key))
        {
            fieldCache[key] = type.GetField(fieldName, 
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        }
        
        return fieldCache[key];
    }
    
    public static MethodInfo GetCachedMethod(Type type, string methodName, Type[] parameterTypes = null)
    {
        string key = $"{type.FullName}.{methodName}";
        if (parameterTypes != null)
        {
            key += "." + string.Join(",", parameterTypes.Select(t => t.Name));
        }
        
        if (!methodCache.ContainsKey(key))
        {
            methodCache[key] = parameterTypes == null 
                ? type.GetMethod(methodName)
                : type.GetMethod(methodName, parameterTypes);
        }
        
        return methodCache[key];
    }
}

3.2 使用委托优化方法调用

csharp

public class OptimizedMethodInvoker : MonoBehaviour
{
    private delegate void DamageDelegate(int amount);
    private Dictionary<Type, DamageDelegate> damageDelegates = new Dictionary<Type, DamageDelegate>();
    
    void Start()
    {
        // 预编译委托
        PrecompileDamageDelegates();
    }
    
    void PrecompileDamageDelegates()
    {
        MonoBehaviour[] components = GetComponents<MonoBehaviour>();
        
        foreach (MonoBehaviour component in components)
        {
            Type type = component.GetType();
            MethodInfo method = type.GetMethod("TakeDamage", new Type[] { typeof(int) });
            
            if (method != null)
            {
                // 创建委托
                DamageDelegate damageDelegate = (DamageDelegate)Delegate.CreateDelegate(
                    typeof(DamageDelegate), component, method);
                
                damageDelegates[type] = damageDelegate;
            }
        }
    }
    
    public void ApplyDamage(int damage)
    {
        foreach (var kvp in damageDelegates)
        {
            kvp.Value(damage); // 性能接近直接调用
        }
    }
}

3.3 表达式树优化属性访问

csharp

using System.Linq.Expressions;

public class FastPropertyAccessor
{
    private Dictionary<string, Func<object, object>> getterCache = new Dictionary<string, Func<object, object>>();
    private Dictionary<string, Action<object, object>> setterCache = new Dictionary<string, Action<object, object>>();
    
    public Func<object, object> CreateGetter(FieldInfo field)
    {
        string key = $"{field.DeclaringType.FullName}.{field.Name}";
        
        if (!getterCache.ContainsKey(key))
        {
            // 创建表达式树： (object obj) => (object)((T)obj).field
            var param = Expression.Parameter(typeof(object), "obj");
            var cast = Expression.Convert(param, field.DeclaringType);
            var fieldAccess = Expression.Field(cast, field);
            var castResult = Expression.Convert(fieldAccess, typeof(object));
            
            var lambda = Expression.Lambda<Func<object, object>>(castResult, param);
            getterCache[key] = lambda.Compile();
        }
        
        return getterCache[key];
    }
    
    public Action<object, object> CreateSetter(FieldInfo field)
    {
        string key = $"{field.DeclaringType.FullName}.{field.Name}";
        
        if (!setterCache.ContainsKey(key))
        {
            // 创建表达式树： (object obj, object value) => ((T)obj).field = (TField)value
            var objParam = Expression.Parameter(typeof(object), "obj");
            var valueParam = Expression.Parameter(typeof(object), "value");
            
            var castObj = Expression.Convert(objParam, field.DeclaringType);
            var castValue = Expression.Convert(valueParam, field.FieldType);
            
            var fieldAccess = Expression.Field(castObj, field);
            var assign = Expression.Assign(fieldAccess, castValue);
            
            var lambda = Expression.Lambda<Action<object, object>>(assign, objParam, valueParam);
            setterCache[key] = lambda.Compile();
        }
        
        return setterCache[key];
    }
}

4. Unity 特定的反射工具类

4.1 组件查找器

csharp

public static class UnityReflectionHelper
{
    // 查找所有实现特定接口的组件
    public static List<T> FindComponentsOfInterface<T>() where T : class
    {
        List<T> results = new List<T>();
        
        MonoBehaviour[] allMonoBehaviours = GameObject.FindObjectsOfType<MonoBehaviour>();
        
        foreach (MonoBehaviour mono in allMonoBehaviours)
        {
            if (mono is T)
            {
                results.Add(mono as T);
            }
        }
        
        return results;
    }
    
    // 通过特性查找组件
    public static List<Component> FindComponentsWithAttribute<TAttribute>() 
        where TAttribute : Attribute
    {
        List<Component> results = new List<Component>();
        
        Component[] allComponents = GameObject.FindObjectsOfType<Component>();
        
        foreach (Component component in allComponents)
        {
            Type type = component.GetType();
            if (type.GetCustomAttribute<TAttribute>() != null)
            {
                results.Add(component);
            }
        }
        
        return results;
    }
    
    // 复制组件值
    public static void CopyComponentValues(Component source, Component target)
    {
        if (source.GetType() != target.GetType())
        {
            Debug.LogError("Component types don't match");
            return;
        }
        
        Type type = source.GetType();
        FieldInfo[] fields = type.GetFields(
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        
        foreach (FieldInfo field in fields)
        {
            // 跳过 Unity 的特殊字段
            if (field.Name == "name" || field.Name == "hideFlags" || 
                field.Name == "gameObject" || field.Name == "transform")
                continue;
                
            object value = field.GetValue(source);
            field.SetValue(target, value);
        }
    }
}

4.2 事件系统动态绑定

csharp

public class DynamicEventBinder : MonoBehaviour
{
    public void BindUnityEvent<T>(UnityEvent<T> unityEvent, object target, string methodName)
    {
        Type targetType = target.GetType();
        MethodInfo method = targetType.GetMethod(methodName, new Type[] { typeof(T) });
        
        if (method != null)
        {
            unityEvent.AddListener((value) => 
            {
                method.Invoke(target, new object[] { value });
            });
        }
    }
    
    public void BindButtonClick(Button button, object target, string methodName)
    {
        Type targetType = target.GetType();
        MethodInfo method = targetType.GetMethod(methodName, Type.EmptyTypes);
        
        if (method != null)
        {
            button.onClick.AddListener(() => 
            {
                method.Invoke(target, null);
            });
        }
    }
}

5. 注意事项和限制

5.1 IL2CPP 限制

csharp

// IL2CPP 下反射的限制
public class IL2CPPReflectionWarning : MonoBehaviour
{
    void Start()
    {
        #if ENABLE_IL2CPP
        Debug.LogWarning("IL2CPP may have restrictions on dynamic code generation");
        
        // 以下可能在 IL2CPP 下无法工作
        // var assembly = Assembly.Load("DynamicAssembly");
        // var type = assembly.GetType("DynamicType");
        // var instance = Activator.CreateInstance(type);
        #endif
    }
}

5.2 AOT 编译平台

csharp

// 为 AOT 平台预先生成代码
[AOT.MonoPInvokeCallback(typeof(Action))]
public static void PreGenerateCode()
{
    // 提前调用可能会用到的反射代码，避免 AOT 剪裁
    Type[] types = {
        typeof(List<int>),
        typeof(Dictionary<string, object>),
        typeof(Vector3),
        typeof(Quaternion)
    };
    
    foreach (Type type in types)
    {
        // 预先生成各种操作
        var fields = type.GetFields();
        var properties = type.GetProperties();
        var methods = type.GetMethods();
    }
}

5.3 安全考虑

csharp

public class SafeReflection : MonoBehaviour
{
    // 白名单机制
    private static HashSet<string> allowedTypes = new HashSet<string>
    {
        "System.String",
        "System.Int32",
        "System.Single",
        "System.Boolean",
        "UnityEngine.Vector3",
        "UnityEngine.Quaternion"
    };
    
    public static bool IsTypeAllowed(string typeName)
    {
        return allowedTypes.Contains(typeName);
    }
    
    public static object SafeCreateInstance(string typeName)
    {
        if (!IsTypeAllowed(typeName))
        {
            Debug.LogError($"Type {typeName} is not allowed for reflection");
            return null;
        }
        
        Type type = Type.GetType(typeName);
        if (type != null)
        {
            return Activator.CreateInstance(type);
        }
        
        return null;
    }
}

6. 实际应用示例

6.1 游戏设置系统

csharp

public class GameSettings : MonoBehaviour
{
    [System.Serializable]
    public class Setting
    {
        public string key;
        public object value;
        public Type valueType;
    }
    
    public List<Setting> settings = new List<Setting>();
    
    public void ApplySettings()
    {
        foreach (Setting setting in settings)
        {
            // 查找所有相关的组件
            MonoBehaviour[] components = FindObjectsOfType<MonoBehaviour>();
            
            foreach (MonoBehaviour component in components)
            {
                Type type = component.GetType();
                FieldInfo field = type.GetField(setting.key, 
                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                
                if (field != null && field.FieldType == setting.valueType)
                {
                    field.SetValue(component, setting.value);
                }
            }
        }
    }
}

6.2 技能系统

csharp

public class SkillSystem : MonoBehaviour
{
    [System.Serializable]
    public class SkillEffect
    {
        public string componentType;
        public string methodName;
        public object[] parameters;
    }
    
    public List<SkillEffect> effects = new List<SkillEffect>();
    
    public void ApplyEffects(GameObject target)
    {
        foreach (SkillEffect effect in effects)
        {
            Type type = Type.GetType(effect.componentType);
            if (type != null)
            {
                Component component = target.GetComponent(type);
                if (component != null)
                {
                    MethodInfo method = type.GetMethod(effect.methodName);
                    if (method != null)
                    {
                        method.Invoke(component, effect.parameters);
                    }
                }
            }
        }
    }
}

总结

Unity 中的反射是一个非常强大的工具，但在使用时需要注意：

  1. 性能：避免在 Update 等频繁调用的方法中使用反射

  2. 平台兼容性：注意 IL2CPP 和 AOT 平台的限制

  3. 缓存优化：对频繁使用的反射结果进行缓存

  4. 安全考虑：特别是对于用户输入的反射调用要进行验证

正确使用反射可以极大提高 Unity 项目的灵活性和可扩展性，特别是在编辑器工具开发、配置系统和插件架构中。

Unity Shader法线贴图详解
tiankongdeyige的博客
05-23 1250
法线贴图 (Normal Map) 是一种凹凸贴图 (Bump Map)。它们是一种特殊的纹理，可让您将表面细节（如凹凸、凹槽和划痕）添加到模型，从而捕捉光线，就像由真实几何体表示一样。
Unity环境渲染与反射探针的深入探索
Xiaoxin的博客
07-25 2758
在Unity游戏开发过程中，环境渲染和物体反射效果对于提升游戏画面的真实感和沉浸感至关重要。本文将详细介绍如何在Unity中实现高质量的环境渲染以及如何使用反射探针（Reflection Probes）来模拟物体的反射效果，帮助开发者创建更加生动和逼真的游戏场景。
【Unity学习笔记】反射
milu_ELK的博客
06-06 2258
在我平时做项目的时候，由于我们做的项目都是很简单的，所以不怎么接触反射机制。最早了解反射机制是关于Invoke的时候，知道可以通过方法名来直接进行Invoke调用，但是由于反射调用存在性能开销较大的问题，因此就没打算深入了解、不过反射作为C#的高级特性，可以不用，但是不能不了解反射(Reflection) 的含义和用法。
unity的特性AttriBute详解
weixin_70271498的博客
04-24 2209
使用场景在Unity编辑器中，特性可以用来自定义脚本组件在Inspector面板中的显示方式，提高开发效率。例子分析使用[Header][Tooltip][Range]等特性来改善Inspector面板的布局和交互性。这个应该是可以在面板上看到这一组的字段，太多字段，不好阅读使用场景在Unity的Inspector面板中，特性可以用来控制自定义属性的显示和编辑方式，提高易用性。例子分析特性用于隐藏公共字段在Inspector面板中的显示，这对于那些不需要用户直接编辑的内部状态变量非常有用。
详解Unity中的射线与射线检测
热门推荐
梦小天幼的博客
04-14 5万+
碰撞检测可以帮助我们实现诸如抵达某个地点自动触发剧情、判断子弹是否击中玩家等功能，但我如果想要实现如当鼠标悬浮某个人物上，自动弹出该人物信息，要如何判断呢？这时使用碰撞检测，从摄像机生成一个透明碰撞体朝着人物移动，等碰撞到了人物再弹出该人物信息？会不会太繁琐了。或许你又会想，若我直接生成一个足够长的透明碰撞体呢，是不是在创建的那一刻就可以触发该人物的弹出信息逻辑？没错这样的确可以，而这就是射线！不过是把无限长的透明碰撞体变为了无限长的一条线，仅此而已。...
Unity Assembly Definition 全面详解
qq_38358224的博客
07-31 1394
Assembly Definition（程序集定义，文件扩展名为.asmdef）是Unity用于定义和管理C#程序集的配置文件。通过它，开发者可以将项目代码划分为多个独立的程序集（Assembly），而不是默认将所有脚本编译到单一的程序集中。程序集在C#中是一个基本概念，它是代码的编译单元，包含编译后的类、结构体等类型，并定义了对其他程序集的引用关系。在Unity中，程序集最终会被编译为DLL文件。编译阶段程序集名称包含的脚本位置1Plugins、Standard Assets下的运行时脚本2。
Untiy 反射(Reflect)详解
weixin_57287213的博客
09-19 1973
本文主要实现了Unity高级特性中的反射特性。配有案例和详细讲解。
Unity中的延迟调用方法详解
YF云飞的博客
08-15 885
Unity提供了Invoke系列方法和协程两种实现延迟调用的方式。InvokeRepeating适合简单周期性任务（如AI决策、资源刷新），而Invoke适用于单次延迟（如技能冷却）。协程则更适合复杂时序控制，支持多步骤延迟、条件等待和高精度定时。性能优化建议包括避免频繁创建协程、减少字符串方法名调用等。根据任务复杂度选择合适方案：简单任务用Invoke，复杂时序用协程，二者结合可构建高效的游戏逻辑系统。
Unity Shader -- 漫反射光照模型
Leh1ng的博客
11-06 1936
本篇主要是UnityShader的漫反射光照模型
C# 和Unity 中的原型模式 详解
qq_38358224的博客
08-14 906
需要避免昂贵的对象创建操作系统需要独立于对象创建和构成的方式需要动态加载或运行时指定对象类型对象状态变化频繁且需要保存历史状态关键要点优先考虑使用实现浅拷贝对于深拷贝，可以选择手动实现或序列化方式C# 9的record类型提供了简洁的原型模式实现注意处理循环引用和资源管理问题考虑使用原型注册表管理常用原型原型模式与C#语言的特性结合良好，合理使用可以显著提高系统性能和灵活性，特别是在需要创建大量相似对象的场景中。
Unity3d ShaderLab开发实战详解pdf+源码
07-19
### Unity3D ShaderLab开发实战详解 #### 一、ShaderLab简介 ShaderLab是一种用于Unity游戏引擎中的着色器语言，它允许开发者直接编写GPU代码来实现复杂的视觉效果。ShaderLab是Unity内置的一种混合了HLSL（High-...
Unity3D内部Shader详解
10-07
尽管Unity文档中提到的Shader主要指的是ShaderLab编写的代码，但实际的顶点着色器和像素着色器仍然使用标准的Cg或HLSL编程语言。 Unity3D内置的Shader被分为五大类：Normal、Transparent、Transparent Cutout、Self...
Unity3D实现镜面反射技术详解
在Unity3D中，镜面反射是一种常见的视觉效果，用于模拟物体表面的反射。这个资源提供了一个实现这种效果的简单方法。脚本分为两个部分：Shader和C#脚本。 首先，我们看Shader部分，名为"FX/MirrorReflection"。这是...
Perforce《2025游戏技术现状报告》Part 3：不同行业挑战以及Unreal、Godot、自研游戏引擎的应用趋势
weixin_49715102的博客
12-05 1486
2025游戏技术现状报告Part 3：聚焦行业挑战与Unreal、Godot、自研游戏引擎的最新趋势。报告称，阻碍创新的头号敌人不是钱，而是“人”？Godot怎么就在非游戏行业火起来了？答案比想象中有趣。
#leetcode# 、
最新发布
wnaan的博客
12-11 543
/ 右端点升序：interval1[1] - interval2[1] 为正则 interval1 在后，负则在前。* 2. 插入产品时，每个字符节点的堆存储以该前缀开头的产品，超出3个则移除最大的（保证堆中是最小的3个）；// 提取 a 的第 i 位二进制值（0 或 1）：右移 i 位后与 1 按位与，仅保留第 i 位。* 时间复杂度：O(n log n)（排序 O(n log n) + 一次遍历 O(n)）* 时间复杂度：O(n log n)（排序 O(n log n) + 一次遍历 O(n)）
幽冥大陆(四十六)人工智能自动化交互系统ASR2——东方仙盟筑基期
cybersnow精通 28 门计算机语言，凭借其超凡的技术能力，成功开发过上万个应用，广泛涉及政府、商业、个人等众多领域，甚至在检察院、环保局、公安局等专业场景中也大放异彩。不仅熟练掌握单片机和物联网开发，在软件架构设计方面更是独树一帜，自创了跨平台软件
12-10 877
在当今数字化时代，自动语音识别（ASR）技术正以前所未有的速度改变着我们与设备交互的方式。在 C# 和浏览器环境中开发 ASR 应用，为开发者开启了一扇通往创新交互体验的大门。对于初学者而言，这既是充满挑战的征程，也是收获满满的学习之旅。
halcon图像增强——emphasize
qq_34059233的博客
12-09 350
我们有时候需要提取图像的边缘进行后续的处理，在提取边缘之前，我们可以对图像的边缘进行增强处理
CAD点集生成泰森多边形(Voronoi图）——CAD二次开发
12-10 168
实现了基于点集生成泰森多边形（Voronoi图）的功能，并能够将生成的Voronoi多边形和Delaunay三角网进行裁剪，以适应指定的边界框。代码主要采用C#编写，依赖于AutoCAD的.NET API。将生成的Voronoi多边形和Delaunay边裁剪到指定的边界框（通过放大输入点集的范围得到）。将结果以多段线（Polyline）的形式添加到AutoCAD模型空间。从AutoCAD中选择点或多段线（提取顶点）作为输入点集。根据Delaunay三角网生成Voronoi图。采用CAD c#开发，
C# 的 out 参数：全面解析与最佳实践
thanklife的专栏
12-10 777
摘要： C#的out参数是一种用于从方法返回多个值的特性，要求方法内部必须为其赋值，调用时变量无需初始化。本文详细解析其基础概念、内存机制及C# 7.0+的改进（如内联声明和_忽略参数），对比out与ref的关键区别（out仅输出，ref双向传递）。最佳实践包括Try-Parse模式，用于安全解析数据。通过代码示例展示多参数返回、现代语法优化及常见应用场景，帮助开发者高效利用这一特性提升代码灵活性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值