Unity中实现真实感光柱反射：从物理追踪到Shader渲染的完整方案

原创于 2026-07-29 11:01:59 发布 · 423 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Agile/PM

代码可运行

1. 项目概述：从“光柱”到“无限反射”的视觉魔法

最近在做一个科幻题材的独立游戏，里面有个核心场景：一个布满镜面的密室，主角需要操控一道激光束，通过镜子的多次反射来解开机关。这个需求听起来挺酷，但Unity引擎里并没有一个现成的“智能反射光柱”组件。网上搜了一圈，发现大家要么用LineRenderer简单画线模拟，反射逻辑很生硬；要么上Ray Tracing，性能开销又太大，移动端根本跑不动。所以，我决定自己动手，实现一个既能在镜子间真实反射、视觉效果又足够炫酷、同时兼顾性能的光柱系统。这不仅仅是画一条线那么简单，它涉及到光线追踪的算法思想、物理反射规律的计算、以及如何用Shader和粒子系统来渲染出有体积感的“光柱”实体。经过几轮迭代和优化，最终效果相当满意，不仅反射精准，光柱的辉光、尘埃效果也很有氛围感。今天就把这套方案的完整思路和实现细节拆解出来，无论是想做解谜游戏、灯光秀还是特效展示，相信都能给你带来直接的参考。

2. 核心思路与方案选型：为什么不用简单的LineRenderer？

接到“镜子反射光柱”的需求，第一反应可能就是Unity自带的 LineRenderer 组件。画一条线，检测碰撞，碰撞点作为新的起点再画一条线，如此循环。这个方法快速、简单，对于原型验证足够了。但我很快发现了它的几个致命缺陷，这也是我决定抛弃这个方案的原因：

首先，是视觉效果的单薄。 LineRenderer 画出来的就是一条“线”，没有体积感，没有光晕，没有因距离而产生的衰减，看起来就像一根彩色的绳子，毫无“光柱”应有的能量感和氛围感。在科幻或魔幻场景中，这种表现力是远远不够的。

其次，是反射逻辑的粗糙。 简单的碰撞检测只能拿到碰撞点和法线，但实现真实的镜面反射，你需要根据入射光的方向和镜面法线，精确计算出反射光的方向。 LineRenderer 方案通常只做简单的“镜像”方向翻转，对于非垂直入射或动态镜子，很容易出错，光线会“滑”走或者反射角度诡异。

最后，是扩展性的局限。 当你想加入光柱的强度衰减、颜色变化、在特定介质（如烟雾）中的可见性（体积光）等效果时，基于 LineRenderer 的架构会变得难以维护和扩展。

因此，我设计的核心方案可以概括为： “CPU端进行物理光线追踪计算 + GPU端进行高质量视觉渲染” 的混合架构。

物理计算层（CPU） ：使用 Raycast （射线检测）来模拟光线的传播。每一帧，从光源原点发射一条射线，检测与场景中“镜子”物体的碰撞。一旦击中，我们严格依据物理光学中的反射定律（入射角等于反射角），计算出精确的反射方向，并以碰撞点为新原点，继续发射下一条射线，直到达到最大反射次数或能量衰减至零。这个过程在 Update 或 FixedUpdate 中完成，生成一个包含所有反射点（ Vector3 ）的列表。
视觉渲染层（GPU） ：将上一步计算出的路径点列表，传递给一个自定义的渲染方案。这个方案负责将干巴巴的点，变成观众眼中充满质感的光柱。我采用了 “胶囊体网格 + 自定义Shader” 的组合。为每一段光路（两个连续点之间）动态生成一个胶囊体网格（Capsule Mesh），其长度和方向与光路对齐。然后，用一个专门编写的Shader来处理颜色、辉光、边缘柔化、甚至内部的噪波流动，从而渲染出有体积、有光晕的动态光柱。

这个方案的优点非常明显： 物理计算准确，视觉表现力强，性能可控（可通过限制反射次数和LOD控制），且易于扩展（Shader可以叠加各种效果） 。下面，我们就深入这两个核心层，看看具体怎么实现。

2.1 物理追踪的核心：递归射线与反射计算

光线追踪的逻辑是整个系统的大脑，必须保证高效和准确。我把它封装在一个独立的 LaserReflectionCalculator 类里。

核心数据结构： 首先，定义一个 ReflectionSegment 结构体来存储每一段光路的信息。

[System.Serializable]
public struct ReflectionSegment
{
    public Vector3 startPoint; // 此段光路的起点
    public Vector3 endPoint;   // 此段光路的终点（也是碰撞点或终点）
    public Vector3 direction;  // 此段光路的方向（单位向量）
    public float remainingIntensity; // 到达此段时的剩余强度
    public GameObject hitObject; // 击中的物体（如果是镜子）
}

递归追踪函数： 关键是一个递归或循环函数，它负责发射射线并处理反射。

public List<ReflectionSegment> CalculateReflectionPath(Vector3 origin, Vector3 initialDirection, float maxDistance, int maxReflections, float initialIntensity = 1.0f)
{
    List<ReflectionSegment> path = new List<ReflectionSegment>();
    Vector3 currentOrigin = origin;
    Vector3 currentDirection = initialDirection.normalized;
    float currentIntensity = initialIntensity;
    int reflectionCount = 0;
    LayerMask mirrorLayer = LayerMask.GetMask("Mirror"); // 建议为镜子物体单独设置一个Layer

    while (reflectionCount <= maxReflections && currentIntensity > intensityThreshold)
    {
        Ray ray = new Ray(currentOrigin, currentDirection);
        RaycastHit hit;

        // 发射射线，只检测“镜子”层
        if (Physics.Raycast(ray, out hit, maxDistance, mirrorLayer))
        {
            ReflectionSegment segment = new ReflectionSegment();
            segment.startPoint = currentOrigin;
            segment.endPoint = hit.point;
            segment.direction = currentDirection;
            segment.remainingIntensity = currentIntensity;
            segment.hitObject = hit.collider.gameObject;
            path.Add(segment);

            // 准备下一次反射
            // 1. 计算反射方向： R = I - 2 * (I·N) * N
            Vector3 incidentVector = currentDirection;
            Vector3 normalVector = hit.normal.normalized; // 确保法线是单位向量
            Vector3 reflectVector = incidentVector - 2 * Vector3.Dot(incidentVector, normalVector) * normalVector;

            currentOrigin = hit.point + reflectVector * 0.001f; // 新起点从碰撞点略微偏移，避免自碰撞
            currentDirection = reflectVector.normalized;

            // 2. 模拟能量衰减：每次反射损失一定强度，也可以根据材质属性来定义
            currentIntensity *= reflectionIntensityLossFactor; // 例如 0.8

            reflectionCount++;
        }
        else
        {
            // 没有击中镜子，射线飞到最大距离
            ReflectionSegment finalSegment = new ReflectionSegment();
            finalSegment.startPoint = currentOrigin;
            finalSegment.endPoint = currentOrigin + currentDirection * maxDistance;
            finalSegment.direction = currentDirection;
            finalSegment.remainingIntensity = currentIntensity;
            finalSegment.hitObject = null;
            path.Add(finalSegment);
            break; // 路径结束
        }
    }
    return path;
}

关键细节与避坑指南：

法线精度 ： hit.normal 是碰撞点的法线，对于曲面镜子或复杂网格，这个值可能不是完美的“镜面”法线。如果你的镜子是标准的平面，确保其网格法线统一。对于复杂表面，可能需要从材质或自定义组件中获取更精确的反射平面法线。
起点偏移 ：计算新原点时，一定要加上一个微小的偏移量（如 0.001f * reflectVector ）。这是为了避免下一帧的射线检测，因为起点恰好落在上一帧的碰撞点表面，导致立即再次“击中”同一个碰撞体，从而引发无限循环或抖动。这个偏移量是解决此类射线追踪问题的经典技巧。
层过滤（LayerMask） ：强烈建议为所有镜子物体设置一个专门的Layer（如“Mirror”）。在 Physics.Raycast 中指定这个LayerMask，可以极大地提升性能并避免光线与无关物体（如墙壁、角色）发生意外碰撞，导致逻辑错误。
性能控制 ： maxReflections （最大反射次数）和 maxDistance （单次射线最大距离）是两个重要的性能阀门。在移动端或复杂场景中，建议将最大反射次数限制在5-8次，单次距离根据场景大小设置。同时，可以加入 currentIntensity 阈值判断，当光强低于某个值时提前终止追踪，模拟光能损耗。

2.2 视觉渲染方案：从点到体的魔法

拿到路径点列表后，下一步就是如何将它们渲染成炫酷的光柱。如前所述，我选择了动态生成胶囊体网格的方案。为什么是胶囊体而不是圆柱体？因为胶囊体两端是半球形的，在Shader中处理端点辉光过渡更自然，视觉效果更好。

动态网格生成器： 创建一个 LaserBeamRenderer 类，负责根据 ReflectionSegment 列表生成网格。

public class LaserBeamRenderer : MonoBehaviour
{
    public float beamRadius = 0.1f; // 光柱半径
    public int radialSegments = 8; // 横截面圆的分段数，影响圆滑度
    public Material beamMaterial; // 光柱材质

    private MeshFilter meshFilter;
    private MeshRenderer meshRenderer;
    private List<Vector3> vertices = new List<Vector3>();
    private List<int> triangles = new List<int>();
    private List<Vector2> uvs = new List<Vector2>();

    void Start()
    {
        meshFilter = gameObject.AddComponent<MeshFilter>();
        meshRenderer = gameObject.AddComponent<MeshRenderer>();
        meshRenderer.material = beamMaterial;
    }

    public void UpdateBeamMesh(List<ReflectionSegment> segments)
    {
        vertices.Clear();
        triangles.Clear();
        uvs.Clear();

        if (segments == null || segments.Count == 0)
        {
            meshFilter.mesh = null;
            return;
        }

        foreach (var segment in segments)
        {
            AddCapsuleSegment(segment.startPoint, segment.endPoint, segment.remainingIntensity);
        }

        Mesh mesh = new Mesh();
        mesh.SetVertices(vertices);
        mesh.SetTriangles(triangles, 0);
        mesh.SetUVs(0, uvs);
        mesh.RecalculateNormals(); // 对光照和某些Shader计算有用
        mesh.RecalculateBounds();

        meshFilter.mesh = mesh;
    }

    private void AddCapsuleSegment(Vector3 start, Vector3 end, float intensity)
    {
        Vector3 direction = (end - start).normalized;
        float length = Vector3.Distance(start, end);
        // 胶囊体中间圆柱部分的长度
        float cylinderLength = length - beamRadius * 2;
        if (cylinderLength < 0) cylinderLength = 0; // 如果两点非常近，则退化为一个球体

        // 构建局部坐标系：方向为Z轴
        Vector3 localUp = (Mathf.Abs(Vector3.Dot(direction, Vector3.up)) > 0.9f) ? Vector3.forward : Vector3.up;
        Vector3 localRight = Vector3.Cross(direction, localUp).normalized;
        Vector3 localActualUp = Vector3.Cross(localRight, direction).normalized;

        int startVertIndex = vertices.Count;

        // 生成圆柱体部分的顶点（两个圆）
        for (int i = 0; i <= radialSegments; i++)
        {
            float angle = (float)i / radialSegments * Mathf.PI * 2;
            float cosA = Mathf.Cos(angle);
            float sinA = Mathf.Sin(angle);

            Vector3 radialOffset = (cosA * localRight + sinA * localActualUp) * beamRadius;

            // 起点端的圆
            Vector3 vertexStart = start + radialOffset + direction * beamRadius;
            vertices.Add(vertexStart);
            uvs.Add(new Vector2((float)i / radialSegments, 0));

            // 终点端的圆
            Vector3 vertexEnd = start + radialOffset + direction * (beamRadius + cylinderLength);
            vertices.Add(vertexEnd);
            uvs.Add(new Vector2((float)i / radialSegments, 1));
        }

        // 生成圆柱体侧面三角形
        for (int i = 0; i < radialSegments; i++)
        {
            int baseIndex = startVertIndex + i * 2;
            // 两个矩形面片组成一个环带
            triangles.Add(baseIndex);
            triangles.Add(baseIndex + 1);
            triangles.Add(baseIndex + 2);

            triangles.Add(baseIndex + 2);
            triangles.Add(baseIndex + 1);
            triangles.Add(baseIndex + 3);
        }

        // 生成两端的半球帽（简化示例，实际需要更多顶点来平滑）
        // ... 此处省略半球帽的详细顶点和三角形生成代码，原理类似，沿方向轴堆叠多个圆环。
        // 对于原型或要求不高的场合，甚至可以用两个半透明的球体Mesh放在两端来模拟。
    }
}

这段代码是核心中的核心，它动态地为一个光柱段创建了一个胶囊体网格。 radialSegments 参数控制横截面的圆滑度，值越高越圆滑，但顶点数也越多。你需要根据项目性能要求来权衡。

实操心得：网格合并优化 如果你的场景中有多条独立的光柱，为每条光柱都动态生成一个 MeshFilter 和 MeshRenderer ，Draw Call会很高。一个重要的优化技巧是 网格合并（Mesh Combining） 。你可以创建一个全局的 LaserBeamManager ，它收集所有需要渲染的光柱段，在每一帧或当路径变化时，将所有段的顶点、三角形数据合并到一个大的Mesh中，然后只用一个 MeshRenderer 来绘制。这能将数十个Draw Call合并为1个，对性能提升巨大，尤其是在移动平台上。Unity的 CombineMeshes 方法可以辅助完成，但注意处理材质和UV。

3. 让光柱“活”起来：Shader与后期效果

有了网格，我们只是有了一个白色的3D胶囊体。要让它看起来像一束“光”，就需要Shader的魔法了。这里的目标是： 核心亮度、边缘辉光、能量衰减感、以及可能的动态纹理 。

3.1 基础光柱Shader（Unlit，带菲涅尔效应）

我们编写一个Surface Shader或者Unlit Shader。这里以一个简化的Unlit Shader为例，重点实现核心效果。

Shader "Custom/LaserBeam"
{
    Properties
    {
        _MainColor ("Core Color", Color) = (1, 0.5, 0.2, 1)
        _GlowColor ("Glow Color", Color) = (1, 0.8, 0.4, 0.5)
        _CorePower ("Core Intensity", Range(0, 10)) = 3
        _GlowPower ("Glow Intensity", Range(0, 10)) = 1
        _FresnelPower ("Edge Fresnel", Range(0, 10)) = 2
        _NoiseTex ("Noise Texture", 2D) = "white" {}
        _NoiseSpeed ("Noise Speed", Float) = 1
        _NoiseStrength ("Noise Strength", Range(0, 0.5)) = 0.1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }
        Blend SrcAlpha OneMinusSrcAlpha // 标准Alpha混合
        ZWrite Off // 关闭深度写入，避免透明物体排序问题
        Cull Off // 双面渲染

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float3 worldViewDir : TEXCOORD2;
            };

            fixed4 _MainColor, _GlowColor;
            float _CorePower, _GlowPower, _FresnelPower;
            sampler2D _NoiseTex;
            float4 _NoiseTex_ST;
            float _NoiseSpeed, _NoiseStrength;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _NoiseTex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldViewDir = normalize(WorldSpaceViewDir(v.vertex));
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 1. 基础菲涅尔效应：视线与法线夹角越大，边缘越亮
                float fresnel = 1.0 - saturate(dot(i.worldNormal, i.worldViewDir));
                fresnel = pow(fresnel, _FresnelPower);

                // 2. 核心亮度（假设UV的V方向是光柱长度方向，核心在中心）
                float coreMask = 1.0 - abs(i.uv.y * 2.0 - 1.0); // 从两端到中心，值从0到1再到0
                coreMask = pow(coreMask, _CorePower);

                // 3. 叠加噪声纹理，让光柱内部有流动感
                float2 noiseUV = i.uv;
                noiseUV.x += _Time.y * _NoiseSpeed; // 让噪声沿长度方向流动
                float noise = tex2D(_NoiseTex, noiseUV).r;
                noise = noise * 2.0 - 1.0; // 映射到[-1, 1]
                coreMask += noise * _NoiseStrength;

                // 4. 混合核心色和辉光色
                fixed4 coreColor = _MainColor * coreMask;
                fixed4 glowColor = _GlowColor * fresnel;
                fixed4 finalColor = coreColor + glowColor;

                // 5. 根据UV的V坐标模拟长度方向上的强度衰减（可选，由CPU传入强度值更佳）
                // float lengthAttenuation = i.uv.y; // 假设起点强度高，终点强度低
                // finalColor.a *= lengthAttenuation;

                finalColor.a = saturate(finalColor.a); // 确保Alpha在[0,1]
                return finalColor;
            }
            ENDCG
        }
    }
    FallBack "Transparent/VertexLit"
}

这个Shader做了几件事：

菲涅尔效应 ：让光柱的边缘比中心更亮，这是很多发光体的视觉特征。
核心亮度 ：通过UV的V坐标，模拟光柱从中心向两端衰减的效果， _CorePower 控制衰减的锐利度。
动态噪声 ：采样一张噪声图并让其流动，给光柱内部添加一种“能量湍流”的不稳定感，大大增强了动态效果。
颜色混合 ：将核心的亮色和边缘的辉光色相加，得到最终颜色。

Shader调试技巧 ：在Unity中，你可以将不同的中间变量（如 fresnel , coreMask ）直接输出为颜色，来可视化调试效果。例如 return fixed4(fresnel, fresnel, fresnel, 1); 可以查看菲涅尔因子的分布。

3.2 注入灵魂：粒子系统与后期处理

仅有Shader渲染的静态光柱还不够“炫”。我们可以用粒子系统来添加一些细节，并用后期处理来提升整体氛围。

1. 端点火花与碰撞尘埃： 在光柱的起点（光源）和每次反射的碰撞点，附加一个小型的粒子系统（Particle System）。

起点：可以发射一些持续产生的、细小的光点或星尘，模拟光源处的能量喷射。
碰撞点 ：当光线击中镜子时，可以触发一个短暂的粒子爆发，模拟光能撞击镜面时溅射出的火花或尘埃。这需要脚本控制，在 CalculateReflectionPath 函数中检测到新的碰撞点时，实例化或播放对应位置的粒子效果。

2. 体积光与God Ray（上帝之光）： 这是提升场景氛围的大杀器。当光柱穿过有体积感的介质（如空气中的灰尘、烟雾）时，你应该能看到清晰的光路。实现这个有几种方法：

全屏后处理（Screen Space） ：使用Unity的Post Processing Stack V2，启用“Bloom”（辉光）效果。将光柱的Shader的发光部分（辉光颜色）的亮度提高，Bloom会自动将这些高亮区域扩散开来，形成柔和的辉光。调整Bloom的阈值（Threshold）和强度（Intensity）来达到理想效果。
体积光Shader ：更高级的做法是编写一个专门的体积光（Volumetric Light）Shader。这通常需要深度纹理（Depth Texture）和射线步进（Ray Marching）算法，计算量较大，但效果也最真实。对于移动端，可以简化，比如用多个叠加的半透明面片（Billboard）沿着光柱路径排列，并应用一个模糊的纹理来模拟光雾。

3. 与场景交互：光斑与投影 镜子反射光柱的最终目的，往往是照射到某个目标物体上（如传感器、符文）。当光柱终点落在非镜子物体上时，我们应该在那里生成一个光斑。

实现方法 ：在终点处，放置一个朝向地面的聚光灯（Spot Light）或一个投影器（Projector）。聚光灯简单直接，能产生实时阴影，但性能开销大。投影器性能更好，它可以投射一张圆形渐变的纹理来模拟光斑，但可能不兼容所有渲染管线（如URP/HDRP需要额外处理）。选择哪种取决于你的项目需求和目标平台。

4. 性能优化与实战调试笔记

将所有这些功能组合在一起后，一个完整的光柱反射系统就诞生了。但在实际项目中，尤其是移动端或VR项目中，性能是必须跨过的坎。以下是我在实战中总结的优化清单和调试经验。

4.1 多层次细节（LOD）与裁剪

距离裁剪 ：为 LaserBeamRenderer 添加一个距离判断。当摄像机与光柱起点的距离超过某个阈值时，直接停止渲染该光柱的网格，或者切换到一个更低精度的模型（比如 radialSegments 从16降到4）。
屏幕空间尺寸裁剪 ：计算光柱在屏幕空间中所占像素的大小。如果它非常小（比如小于10个像素），则用一条简单的 LineRenderer 甚至一个Sprite来替代复杂的胶囊体网格。这可以通过 Camera.WorldToScreenPoint 计算起点和终点的屏幕坐标，然后估算距离来实现。
反射次数动态调整 ：可以根据光柱的强度或与摄像机的距离，动态减少 maxReflections 。远处的、微弱的光线，反射一两次就够了。

4.2 计算与渲染频率优化

非每帧更新 ：除非光源或镜子在剧烈运动，否则光柱的路径不需要每帧都重新计算。可以通过一个阈值来判断：如果光源的位置/旋转变化量小于某个值，且所有相关镜子的位置/旋转变化量也小于某个值，则跳过本帧的路径计算和网格更新。这能节省大量CPU开销。
Job System与Burst Compiler ：对于拥有大量、需要复杂计算的光柱系统（比如上百条），可以考虑使用Unity的C# Job System和Burst Compiler来并行化射线追踪计算。将每条光线的追踪任务封装成一个IJob，可以显著提升多核CPU的利用率。不过，这属于进阶优化，需要对ECS/Job System有一定了解。

4.3 常见问题与排查实录

在开发过程中，我踩过不少坑，这里记录下最典型的几个问题和解决方法：

问题一：光线“穿墙”或反射点抖动。

现象：光线偶尔会穿过薄墙，或者在镜子边缘反射时，反射点在不同帧之间剧烈跳动。
原因：最可能的原因是射线的 起点偏移 没做好。如果新射线的起点完全在碰撞点表面，由于浮点数精度问题，它可能被判定为在碰撞体“内部”，导致本次检测失败（穿墙）或与同一碰撞体发生另一次非预期的碰撞（抖动）。
解决：确保在计算新射线原点时，沿反射方向施加一个足够小的偏移量（如 0.001f 到 0.01f ）。这个值需要根据场景比例微调。

问题二：光柱在镜子接缝处“断裂”。

现象：当光线射向由多个小镜子拼接成的大镜面时，在接缝处光柱会突然断开或转向错误。
原因：每个小镜子都有自己的碰撞体（如Box Collider），它们的法线在接缝处可能不连续。射线击中A镜子的边缘，获取的法线可能是A的侧面法线，而不是整个镜面的宏观法线，导致反射方向计算错误。
解决：
1. 物理层面 ：使用一个大的Mesh Collider来覆盖整个镜面区域，确保其表面平滑。
2. 逻辑层面 ：如果必须使用多个碰撞体，可以在检测到碰撞后，不直接使用 hit.normal ，而是通过 hit.collider.transform.forward （假设镜子平面是物体的正前方）来获取一个统一的、基于物体本身的法线。这要求镜子的Transform旋转必须正确对齐。

问题三：透明渲染的排序问题（光柱互相穿透或与场景物体穿插）。

现象：半透明的光柱之间，或者光柱与其他半透明物体（如窗户、烟雾）之间，渲染顺序错乱，看起来像穿模。
原因：Unity对于半透明物体（Shader中Blend打开的物体）默认使用“从后往前”的渲染顺序，并且依赖其网格包围盒的中心到摄像机的距离进行排序。当多个光柱交织时，排序很容易出错。
解决：
1. 调整渲染队列（Render Queue） ：在Shader的Tags里明确指定一个靠后的队列，比如 "Queue"="Transparent+100" ，让所有光柱在所有标准透明物体之后渲染。但光柱之间的顺序问题依旧。
2. 使用Alpha Test替代Alpha Blend ：如果光柱的边缘是硬切的（比如卡通风格），可以将Shader的混合模式改为 AlphaTest ，并设置一个裁剪阈值。这样它就可以写入深度缓冲区，排序问题就解决了，但会失去边缘柔化的效果。
3. 深度写入（ZWrite）的权衡 ：尝试将Shader的 ZWrite 设为 On ，但 Blend 仍为透明混合。这有时能改善穿插，但可能导致半透明物体内部的前后表面渲染异常。这是一个需要根据具体效果进行测试和妥协的选项。
4. 终极方案：渲染纹理（Render Texture）合并 ：将所有光柱渲染到一个单独的Render Texture中，然后再将这个纹理叠加到主画面。这样光柱之间就没有排序问题了，它们作为一个整体与场景排序。这是最稳定但实现也最复杂的方法。

问题四：移动端发热严重，帧率下降。

现象：在手机上运行，很快手机发烫，游戏帧率从60fps掉到30fps甚至更低。
原因：动态生成网格（每帧）、复杂的Shader计算（特别是片段Shader中的噪声和多次采样）、过多的粒子系统、实时光照（如果用了聚光灯）都是性能杀手。
解决：
1. Profile! 首先使用Unity Profiler（特别是Deep Profile）或移动端性能分析工具，定位是CPU瓶颈（可能是网格生成或射线计算）还是GPU瓶颈（可能是Shader过度复杂或Overdraw严重）。
2. 简化网格 ：降低 radialSegments （如从12降到6），减少胶囊体半球帽的细分程度。
3. 简化Shader ：移除或简化噪声计算、降低菲涅尔计算的精度、减少纹理采样次数。考虑为移动端制作一个简化版的Shader。
4. 减少粒子数量 ：降低火花、尘埃粒子的最大数量、发射率和生命周期。
5. 烘焙光照 ：如果光斑是静态的，考虑将聚光灯的光照烘焙到光照贴图中，运行时关闭实时光源。

实现镜子间反射光柱的过程，是一个典型的将算法（光线追踪）、图形学（Shader编程）和工程优化（性能管理）结合起来的案例。它没有使用任何黑科技，但每一步都需要对Unity引擎和3D图形基础有扎实的理解。从最初简陋的线条，到最终充满能量感、能与场景动态交互的光柱，这种视觉和逻辑上的提升，对于游戏沉浸感的贡献是巨大的。希望这篇详细的拆解，能帮你少走弯路，更快地创造出属于你自己的那道“光”。

标签

#Unity #光线追踪 #Shader