UE hard/soft reference| DDX DDY | Unity pcg color

最新推荐文章于 2025-02-27 17:28:41 发布

charon8778

最新推荐文章于 2025-02-27 17:28:41 发布

阅读量1.5k

点赞数 23

分类专栏：虚幻引擎游戏开发计算机图形学文章标签：游戏引擎

本文链接：https://blog.csdn.net/charon8778/article/details/143193518

版权

虚幻引擎游戏开发同时被 2 个专栏收录

33 篇文章

订阅专栏

计算机图形学

24 篇文章

订阅专栏

1.虚幻引擎性能优化（附0跳转Unity对应机制）

hard reference and soft reference

1. 硬引用（Hard Reference）

2. 软引用（Soft Reference）

附1：Unity中类似硬引用和软引用的机制

1.虚幻引擎性能优化（附0跳转Unity对应机制）

hard reference and soft reference

在虚幻引擎中，硬引用（Hard Reference）和软引用（Soft Reference）各自有不同的内存管理和加载行为。硬引用保证了资源在对象加载时立即可用，但会占用更多内存；软引用则适合需要动态加载的资源，在优化加载时间和内存使用方面有很大优势，但需要管理资源的加载和卸载。

1. 硬引用（Hard Reference）

定义：硬引用是直接引用资源对象的方式。使用硬引用的对象在加载时会立即加载其所有的被引用资源。
加载行为：一旦对象加载，所有硬引用的资源会被强制加载到内存中。这可能会导致较长的加载时间，尤其是当引用的资源较大时。
内存管理：硬引用的资源始终驻留在内存中，直到引用它们的对象被销毁。
适用场景：适合始终需要的资源，例如核心游戏逻辑和界面中持续显示的资源。
示例：UObject* MyObject 是一个硬引用，编译时直接生成对象引用。

2. 软引用（Soft Reference）

定义：软引用（也称为“弱引用”）是一种延迟加载的引用方式。资源在使用时才被加载到内存。
加载行为：使用软引用的资源不会立即加载，只有在明确请求资源时才会被加载。这减少了初始加载时间。
内存管理：软引用的资源只有在需要时才加载，可以在不需要时从内存中卸载，节省内存。
适用场景：适合非关键资源或不一定总是需要的资源，例如备用的武器模型、装饰对象等。
示例：TSoftObjectPtr<UObject> MySoftObject 是一个软引用，需要在代码中手动调用 LoadSynchronous() 方法或使用异步加载来实际加载资源。

3. 使用原则

硬引用：用于常驻内存、频繁使用或关键的资源，以确保稳定性。
软引用：用于可选资源或在某些特定条件下才需要的资源，优化内存和加载时间。

2.空间梯度转法线

DDX DDY节点

DDX DDY节点使用：可以使用它们来计算法线贴图的屏幕空间梯度。
虚幻引擎中的heightToNormal节点解释： cheap blur by stacking them or to generate outlines/lines by color difference

3.ddx和ddy节点深入解释

DDX 和 DDY 节点用于计算纹理或材质输入的屏幕空间导数。这些节点的原理涉及微积分中的偏导数，可以帮助实现抗锯齿和 mipmapping 等效果。以下是这两个节点的微积分解释：

1. DDX 和 DDY 的定义

DDX (Partial Derivative in X direction)：DDX 节点计算出材质输入在屏幕 X 方向上的偏导数，表示在屏幕水平轴上输入值的变化率。
DDY (Partial Derivative in Y direction)：DDY 节点计算出材质输入在屏幕 Y 方向上的偏导数，表示在屏幕垂直轴上输入值的变化率。

简单来说，DDX 和 DDY 分别对应输入在屏幕上水平方向和垂直方向的变化率。这些偏导数是基于像素间的差异计算的，帮助确定每个像素应该显示的细节程度。

2. 微积分解释

在微积分中，偏导数表示一个函数沿某个变量方向上的变化率。在这里，材质的输入值 f(x, y) 是一个二维函数，DDX 和 DDY 分别计算沿 X 和 Y 方向的变化率：

DDX(f) ≈ ∂f∂x\frac{\partial f}{\partial x}∂x∂f
DDY(f) ≈ ∂f∂y\frac{\partial f}{\partial y}∂y∂f

具体来说，DDX(f) 近似地表示相邻像素之间的输入值在 X 方向上的变化量，而 DDY(f) 表示相邻像素之间在 Y 方向上的变化量。虚幻引擎通过采样相邻像素来计算这些导数，称为“有限差分法”。

3. 应用场景

Mipmapping：当计算出导数后，可以知道当前像素输入的变化速度。如果变化率大，则需要选择更低级别的纹理贴图（即更模糊的 mip 级别），以减少纹理细节上的锯齿。
抗锯齿：对于一些需要平滑处理的效果（例如法线贴图或细节纹理），使用导数可以帮助实现更平滑的过渡。
流动效果：如果使用 DDX 和 DDY 计算偏导数，可以得到材质在屏幕上的流动方向或变化趋势，从而控制纹理偏移、UV 扭曲等。

4. 公式和示例

假设 f(x, y) 是一个像素在屏幕上的 UV 坐标或颜色值，DDX(f) 和 DDY(f) 的计算方式如下：

DDX(f) ≈ f(x+Δx,y)−f(x,y)f(x + \Delta x, y) - f(x, y)f(x+Δx,y)−f(x,y)
DDY(f) ≈ f(x,y+Δy)−f(x,y)f(x, y + \Delta y) - f(x, y)f(x,y+Δy)−f(x,y)

这里 Δx\Delta xΔx 和 Δy\Delta yΔy 是屏幕上相邻像素的距离。在材质编辑器中使用 DDX 和 DDY 可以将这些偏导数用于纹理的自适应采样、抗锯齿、动态效果等。

总结

DDX 和 DDY 是计算偏导数的工具，提供材质输入在 X 和 Y 方向上的变化率。
这些节点帮助虚幻引擎根据屏幕空间的变化来动态调整材质，进而优化视觉效果，减少锯齿。

4.偏导数

1. 偏导数的定义

假设有一个多元函数 f(x,y)f(x, y)f(x,y)，其值依赖于变量 xxx 和 yyy。偏导数表示 fff 相对于其中一个变量的变化率：

相对于 xxx 的偏导数：记为 ∂f∂x\frac{\partial f}{\partial x}∂x∂f，表示在 yyy 不变的情况下，fff 随 xxx 的变化率。
相对于 yyy 的偏导数：记为 ∂f∂y\frac{\partial f}{\partial y}∂y∂f，表示在 xxx 不变的情况下，fff 随 yyy 的变化率。

偏导数符号中的 ∂\partial∂ 用于区别普通导数 ddd，因为偏导数涉及多元函数的多个变量。

2. 几何解释

在几何上，偏导数可以理解为函数图形在某个方向上的“斜率”。例如：

∂f∂x\frac{\partial f}{\partial x}∂x∂f 表示函数 f(x,y)f(x, y)f(x,y) 在 xxx 方向的斜率，即图形在 xxx 方向的变化趋势。
∂f∂y\frac{\partial f}{\partial y}∂y∂f 表示函数 f(x,y)f(x, y)f(x,y) 在 yyy 方向的斜率。

可以把它想象成在一个山丘上，分别沿东西（xxx 方向）和南北（yyy 方向）走一步，查看高度的变化。

3. 计算偏导数的例子

假设 f(x,y)=x2+y2f(x, y) = x^2 + y^2f(x,y)=x2+y2，计算它的偏导数：

相对于 xxx 的偏导数：保持 yyy 不变，对 xxx 求导数：
∂f∂x=2x\frac{\partial f}{\partial x} = 2x∂x∂f=2x
相对于 yyy 的偏导数：保持 xxx 不变，对 yyy 求导数：
∂f∂y=2y\frac{\partial f}{\partial y} = 2y∂y∂f=2y

这表示在 xxx 增大时，f(x,y)f(x, y)f(x,y) 的变化率为 2x2x2x；在 yyy 增大时，f(x,y)f(x, y)f(x,y) 的变化率为 2y2y2y。

4. 偏导数的应用

偏导数广泛用于计算中，特别是在涉及到二维或多维数据的场合，例如：

机器学习：用于优化函数，调整模型参数。
物理学：描述多维空间中不同方向的变化，例如电场、重力场的分布。
计算机图形学：如虚幻引擎中的 DDX 和 DDY，用于计算纹理在屏幕空间中的变化率，从而动态调整渲染效果。

附0：C#程序化生成不同高度的颜色C#：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(MeshFilter))]
public class mesh_generator : MonoBehaviour
{
    Mesh mesh;
    Vector3[] vertices;
    int[] triangles;
    Color[] colors;

    public int xSize = 20;
    public int zSize = 20;

    public Gradient gradient;

    float minTerrainHeight;
    float maxTerrainHeight;
    //normalize height


    //vertex count = (xSize+1)*(zSize+1)

    void Start()
    {
        mesh = new Mesh();
        GetComponent<MeshFilter>().mesh = mesh;

        CreateShape();
        UpdateMesh();
    }

    // Update is called once per frame
    void CreateShape()
    {
        vertices = new Vector3[(xSize + 1) * (zSize + 1)];

        for (int i = 0,z =0; z <= zSize; z++)
        {
            
            for(int x = 0; x <= xSize; x++)
            {
                float y = Mathf.PerlinNoise(x*.4f, z * .4f) * 2f;//*.3f  for scale
                vertices[i] = new Vector3(x, y, z);

                if(y>maxTerrainHeight)
                    maxTerrainHeight = y;
                if(y<minTerrainHeight)
                    minTerrainHeight = y;
                //这两行代码用于跟踪地形的最高和最低点。
                //每生成一个新的 y 值（高度），都会检查它是否比当前的 maxTerrainHeight 
                //或 minTerrainHeight 更大或更小
                //从而更新这些变量。minTerrainHeight 和 maxTerrainHeight 在后续用于颜色渐变
                //（例如，生成一个从山谷到山顶的颜色过渡）。

                i++;
            }
        }

        triangles = new int[xSize*zSize*6];
        int vert = 0;
        int index =0;

        for (int z = 0; z < zSize; z++)
        {
            for (int x = 0; x < xSize; x++)
            {
                triangles[index + 0] = vert + 0;
                triangles[index + 1] = vert + xSize + 1;
                triangles[index + 2] = vert + 1;

                triangles[index + 3] = vert + 1;
                triangles[index + 4] = vert + xSize + 1;
                triangles[index + 5] = vert + xSize + 2;

                vert++;
                index += 6;
            }
            vert++;//3*3, 行结束后 vert++,vert = 4, index = 18
        }

        //uvs = new Vector2[vertices.Length];
        colors = new Color[vertices.Length];//创建一个 colors 数组，长度同 vertices 顶点数组。存储每个顶点对应颜色值。
        for (int i = 0, z = 0; z <= zSize; z++)
        {

            for (int x = 0; x <= xSize; x++)
            {
                //uvs[i]=new Vector2((float)x/xSize,(float)z/zSize);
                float height = Mathf.InverseLerp(minTerrainHeight, maxTerrainHeight, vertices[i].y);
                //Mathf.InverseLerp 函数将 vertices[i].y（顶点的高度）映射到一个 0 到 1 的范围。
                colors[i] = gradient.Evaluate(height);
                //gradient.Evaluate(height) 根据高度 height 从 gradient 中获取对应的颜色。
                //将计算得到的颜色存储到 colors[i] 中，与顶点 vertices[i] 一一对应。
                i++;
            }
        }

    }

    void UpdateMesh()
    {
        mesh.Clear();
        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.colors = colors;

        mesh.RecalculateNormals();
    }
}

逆插值函数解释：

Mathf.InverseLerp(float min, float max, float value)

参数解释:

min: 范围的最小值。
max: 范围的最大值。
value: 需要进行归一化的值。

result=value−min/max−min

这个函数之所以叫做逆向插值（Inverse Lerp），是因为它完成了与普通**线性插值（Lerp）**相反的操作。

Mathf.Lerp(float a, float b, float t) 给定两个值 a 和 b，以及插值系数 t（在 [0, 1] 范围内），返回 a 和 b 之间按 t 的比例插值后的值value。

Mathf.InverseLerp(float min, float max, float value) 的作用是给定 value 在 min 和 max 之间，反向求解位置比例 t，表示 value 距离 min 和 max 的相对位置。

附1：Unity中类似硬引用和软引用的机制

在 Unity 中，没有完全相同的术语或系统。但有以下对应机制：

直接引用类似于硬引用，适合需要常驻的资源。直接引用通常指的是在脚本中直接通过 public 或 [SerializeField] 变量引用资源。
Addressables 中的 AssetReference 提供了类似软引用的功能，支持延迟加载和内存管理。
Resources.Load() 也可以用来动态加载资源，但缺少 Addressables 的强大内存管理功能。

Unity 的 Addressables 是官方推荐的资源管理工具，它更接近于 Unreal Engine 的软引用，特别适合需要动态加载和卸载资源的项目。