Unity无需Shader实现镜子效果

Unity Shader镜面效果 原理:使用Render Texture作为贴图,贴到镜子上 Shader "Mirror" { Properties { _MainTex ("Texture", 2D) = "white" {} } SubShader { Tags { "RenderType"="Opaque" } LOD 100 ... 阅读详情

Unity镜子效果制作教程
 

 


本文提供全流程,中文翻译。

Chinar 坚持将简单的生活方式,带给世人!

(拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例)

 


Chinar —— 心分享、心创新!

助力快速实现一个简单的镜面反射效果

为新手节省宝贵的时间,避免采坑!

 

Chinar 教程效果: 
这里写图片描述


 

 


 

全文高清图片,点击即可放大观看 (很多人竟然不知道)

 


1

Create Mirror —— 创建镜子

 

本教程,无需自己找镜子Shader,只需2个脚本即可在Unity中创建一个简单的模拟镜面反射效果

1. 在场景中创建一个 Plane —— 用来作为镜子

2. 同时创建一个材质球 /Material —— 给到 Plane 上

3. 修改新创建的 Material 的 Shader 为 Unlit/Texture

举个栗子黑白88 
这里写图片描述


2

Create Camera —— 创建一个新相机


1. 新建一个 Render Texture(我改名为 Plane 便于区分和理解)

2. 右键 层次列表/Hierarchy —— 创建一个新的 Camera

3. 将新建的 Render Texture(Plane)给新建的 Camera 组件中的 Target Texture

4. 给新建的 Camera相机,添加脚本 ChinarMirrorPlane

并将 Main Camera与 Plane 拖到 Inspector 面板中对应的属性里

5. 给新建的 Camera相机,添加脚本 ChinarMirror ,并将 Plane 拖至 Inspector 面板中

注意: 一定要修改 Plane 材质的属性为: 
这里写图片描述 
具体流程其实很简单,如下 
举个栗子黑白88 
这里写图片描述 
两个脚本,都需要挂载到 Camera:

<span style="color:#000000"><code><span style="color:#000088">using</span> UnityEngine;


<span style="color:#880000"><span style="color:#880000">///</span> <span style="color:#880000"><summary></span></span>
<span style="color:#880000"><span style="color:#880000">///</span> 镜子管理脚本 —— 挂在新建的Camera上</span>
<span style="color:#880000"><span style="color:#880000">///</span> <span style="color:#880000"></summary></span></span>
[ExecuteInEditMode]
<span style="color:#000088">public</span> <span style="color:#000088">class</span> ChinarMirror : MonoBehaviour
{
    <span style="color:#000088">public</span>  GameObject mirrorPlane;  <span style="color:#880000">//镜子</span>
    <span style="color:#000088">public</span>  Camera     mainCamera;   <span style="color:#880000">//主摄像机</span>
    <span style="color:#000088">private</span> Camera     mirrorCamera; <span style="color:#880000">//镜像摄像机</span>


    <span style="color:#000088">private</span> <span style="color:#000088">void</span> <span style="color:#009900">Start</span>()
    {
        mirrorCamera = GetComponent<Camera>();
    }


    <span style="color:#000088">private</span> <span style="color:#000088">void</span> <span style="color:#009900">Update</span>()
    {
        <span style="color:#000088">if</span> (<span style="color:#000088">null</span> == mirrorPlane || <span style="color:#000088">null</span> == mirrorCamera || <span style="color:#000088">null</span> == mainCamera) <span style="color:#000088">return</span>;
        Vector3 postionInMirrorSpace    = mirrorPlane.transform.InverseTransformPoint(mainCamera.transform.position); <span style="color:#880000">//将主摄像机的世界坐标位置转换为镜子的局部坐标位置</span>
        postionInMirrorSpace.y          = -postionInMirrorSpace.y;                                                    <span style="color:#880000">//一般y为镜面的法线方向</span>
        mirrorCamera.transform.position = mirrorPlane.transform.TransformPoint(postionInMirrorSpace);                 <span style="color:#880000">//转回到世界坐标系的位置</span>
    }
}</code></span>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
<span style="color:#000000"><code><span style="color:#000088">using</span> UnityEngine;

<span style="color:#880000">/// <summary></span>
<span style="color:#880000">/// Plane管理脚本 —— 挂载新建的Camera上</span>
<span style="color:#880000">/// </summary></span>
[ExecuteInEditMode] <span style="color:#880000">//编辑模式中执行</span>
<span style="color:#000088">public</span> <span style="color:#000088">class</span> ChinarMirrorPlane : MonoBehaviour
{
    <span style="color:#000088">public</span>  GameObject mirrorPlane; <span style="color:#880000">//镜子Plane</span>
    <span style="color:#000088">public</span>  <span style="color:#000088">bool</span>       estimateViewFrustum    = <span style="color:#000088">true</span>;
    <span style="color:#000088">public</span>  <span style="color:#000088">bool</span>       setNearClipPlane       = <span style="color:#000088">true</span>;   <span style="color:#880000">//是否设置近剪切平面</span>
    <span style="color:#000088">public</span>  <span style="color:#000088">float</span>      nearClipDistanceOffset = -<span style="color:#006666">0.01f</span>; <span style="color:#880000">//近剪切平面的距离</span>
    <span style="color:#000088">private</span> Camera     mirrorCamera;                    <span style="color:#880000">//镜像摄像机</span>
    <span style="color:#000088">private</span> Vector3    vn;                              <span style="color:#880000">//屏幕的法线</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      l;                               <span style="color:#880000">//到屏幕左边缘的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      r;                               <span style="color:#880000">//到屏幕右边缘的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      b;                               <span style="color:#880000">//到屏幕下边缘的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      t;                               <span style="color:#880000">//到屏幕上边缘的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      d;                               <span style="color:#880000">//从镜像摄像机到屏幕的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      n;                               <span style="color:#880000">//镜像摄像机的近剪切面的距离</span>
    <span style="color:#000088">private</span> <span style="color:#000088">float</span>      f;                               <span style="color:#880000">//镜像摄像机的远剪切面的距离</span>
    <span style="color:#000088">private</span> Vector3    pa;                              <span style="color:#880000">//世界坐标系的左下角</span>
    <span style="color:#000088">private</span> Vector3    pb;                              <span style="color:#880000">//世界坐标系的右下角</span>
    <span style="color:#000088">private</span> Vector3    pc;                              <span style="color:#880000">//世界坐标系的左上角</span>
    <span style="color:#000088">private</span> Vector3    pe;                              <span style="color:#880000">//镜像观察角度的世界坐标位置</span>
    <span style="color:#000088">private</span> Vector3    va;                              <span style="color:#880000">//从镜像摄像机到左下角</span>
    <span style="color:#000088">private</span> Vector3    vb;                              <span style="color:#880000">//从镜像摄像机到右下角</span>
    <span style="color:#000088">private</span> Vector3    vc;                              <span style="color:#880000">//从镜像摄像机到左上角</span>
    <span style="color:#000088">private</span> Vector3    vr;                              <span style="color:#880000">//屏幕的右侧旋转轴</span>
    <span style="color:#000088">private</span> Vector3    vu;                              <span style="color:#880000">//屏幕的上侧旋转轴</span>
    <span style="color:#000088">private</span> Matrix4x4  p  = <span style="color:#000088">new</span> Matrix4x4();
    <span style="color:#000088">private</span> Matrix4x4  rm = <span style="color:#000088">new</span> Matrix4x4();
    <span style="color:#000088">private</span> Matrix4x4  tm = <span style="color:#000088">new</span> Matrix4x4();
    <span style="color:#000088">private</span> Quaternion q  = <span style="color:#000088">new</span> Quaternion();


    <span style="color:#000088">private</span> <span style="color:#000088">void</span> Start()
    {
        mirrorCamera = GetComponent<Camera>();
    }


    <span style="color:#000088">private</span> <span style="color:#000088">void</span> Update()
    {
        <span style="color:#000088">if</span> (null == mirrorPlane || null == mirrorCamera) <span style="color:#000088">return</span>;
        pa = mirrorPlane.transform.TransformPoint(<span style="color:#000088">new</span> Vector3(-<span style="color:#006666">5.0f</span>, <span style="color:#006666">0.0f</span>, -<span style="color:#006666">5.0f</span>)); <span style="color:#880000">//世界坐标系的左下角</span>
        pb = mirrorPlane.transform.TransformPoint(<span style="color:#000088">new</span> Vector3(<span style="color:#006666">5.0f</span>,  <span style="color:#006666">0.0f</span>, -<span style="color:#006666">5.0f</span>)); <span style="color:#880000">//世界坐标系的右下角</span>
        pc = mirrorPlane.transform.TransformPoint(<span style="color:#000088">new</span> Vector3(-<span style="color:#006666">5.0f</span>, <span style="color:#006666">0.0f</span>, <span style="color:#006666">5.0f</span>));  <span style="color:#880000">//世界坐标系的左上角</span>
        pe = transform.position;                                                    <span style="color:#880000">//镜像观察角度的世界坐标位置</span>
        n  = mirrorCamera.nearClipPlane;                                            <span style="color:#880000">//镜像摄像机的近剪切面的距离</span>
        f  = mirrorCamera.farClipPlane;                                             <span style="color:#880000">//镜像摄像机的远剪切面的距离</span>
        va = pa - pe;                                                               <span style="color:#880000">//从镜像摄像机到左下角</span>
        vb = pb - pe;                                                               <span style="color:#880000">//从镜像摄像机到右下角</span>
        vc = pc - pe;                                                               <span style="color:#880000">//从镜像摄像机到左上角</span>
        vr = pb - pa;                                                               <span style="color:#880000">//屏幕的右侧旋转轴</span>
        vu = pc - pa;                                                               <span style="color:#880000">//屏幕的上侧旋转轴</span>
        <span style="color:#000088">if</span> (Vector3.Dot(-Vector3.Cross(va, vc), vb) < <span style="color:#006666">0.0f</span>)                         <span style="color:#880000">//如果看向镜子的背面</span>
        {
            vu = -vu;
            pa = pc;
            pb = pa + vr;
            pc = pa + vu;
            va = pa - pe;
            vb = pb - pe;
            vc = pc - pe;
        }
        vr.Normalize();
        vu.Normalize();
        vn = -Vector3.Cross(vr, vu); <span style="color:#880000">//两个向量的叉乘,最后在取负,因为Unity是使用左手坐标系</span>
        vn.Normalize();
        d = -Vector3.Dot(va, vn);
        <span style="color:#000088">if</span> (setNearClipPlane)
        {
            n                          = d + nearClipDistanceOffset;
            mirrorCamera.nearClipPlane = n;
        }
        l = Vector3.Dot(vr, va) * n / d;
        r = Vector3.Dot(vr, vb) * n / d;
        b = Vector3.Dot(vu, va) * n / d;
        t = Vector3.Dot(vu, vc) * n / d;


        <span style="color:#880000">//投影矩阵</span>
        p[<span style="color:#006666">0</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">2.0f</span> * n / (r - l);
        p[<span style="color:#006666">0</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">0</span>, <span style="color:#006666">2</span>] = (r + l) / (r - l);
        p[<span style="color:#006666">0</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        p[<span style="color:#006666">1</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">1</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">2.0f</span> * n / (t - b);
        p[<span style="color:#006666">1</span>, <span style="color:#006666">2</span>] = (t + b) / (t - b);
        p[<span style="color:#006666">1</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        p[<span style="color:#006666">2</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">2</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">2</span>, <span style="color:#006666">2</span>] = (f + n) / (n - f);
        p[<span style="color:#006666">2</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">2.0f</span> * f * n / (n - f);

        p[<span style="color:#006666">3</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">3</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        p[<span style="color:#006666">3</span>, <span style="color:#006666">2</span>] = -<span style="color:#006666">1.0f</span>;
        p[<span style="color:#006666">3</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        <span style="color:#880000">//旋转矩阵</span>
        rm[<span style="color:#006666">0</span>, <span style="color:#006666">0</span>] = vr.x;
        rm[<span style="color:#006666">0</span>, <span style="color:#006666">1</span>] = vr.y;
        rm[<span style="color:#006666">0</span>, <span style="color:#006666">2</span>] = vr.z;
        rm[<span style="color:#006666">0</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        rm[<span style="color:#006666">1</span>, <span style="color:#006666">0</span>] = vu.x;
        rm[<span style="color:#006666">1</span>, <span style="color:#006666">1</span>] = vu.y;
        rm[<span style="color:#006666">1</span>, <span style="color:#006666">2</span>] = vu.z;
        rm[<span style="color:#006666">1</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        rm[<span style="color:#006666">2</span>, <span style="color:#006666">0</span>] = vn.x;
        rm[<span style="color:#006666">2</span>, <span style="color:#006666">1</span>] = vn.y;
        rm[<span style="color:#006666">2</span>, <span style="color:#006666">2</span>] = vn.z;
        rm[<span style="color:#006666">2</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">0.0f</span>;

        rm[<span style="color:#006666">3</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        rm[<span style="color:#006666">3</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        rm[<span style="color:#006666">3</span>, <span style="color:#006666">2</span>] = <span style="color:#006666">0.0f</span>;
        rm[<span style="color:#006666">3</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">1.0f</span>;

        tm[<span style="color:#006666">0</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">1.0f</span>;
        tm[<span style="color:#006666">0</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">0</span>, <span style="color:#006666">2</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">0</span>, <span style="color:#006666">3</span>] = -pe.x;

        tm[<span style="color:#006666">1</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">1</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">1.0f</span>;
        tm[<span style="color:#006666">1</span>, <span style="color:#006666">2</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">1</span>, <span style="color:#006666">3</span>] = -pe.y;

        tm[<span style="color:#006666">2</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">2</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">2</span>, <span style="color:#006666">2</span>] = <span style="color:#006666">1.0f</span>;
        tm[<span style="color:#006666">2</span>, <span style="color:#006666">3</span>] = -pe.z;

        tm[<span style="color:#006666">3</span>, <span style="color:#006666">0</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">3</span>, <span style="color:#006666">1</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">3</span>, <span style="color:#006666">2</span>] = <span style="color:#006666">0.0f</span>;
        tm[<span style="color:#006666">3</span>, <span style="color:#006666">3</span>] = <span style="color:#006666">1.0f</span>;


        mirrorCamera.projectionMatrix    = p; <span style="color:#880000">//矩阵组</span>
        mirrorCamera.worldToCameraMatrix = rm * tm;
        <span style="color:#000088">if</span> (!estimateViewFrustum) <span style="color:#000088">return</span>;
        q.SetLookRotation((<span style="color:#006666">0.5f</span> * (pb + pc) - pe), vu); <span style="color:#880000">//旋转摄像机</span>
        mirrorCamera.transform.rotation = q;            <span style="color:#880000">//聚焦到屏幕的中心点</span>

        <span style="color:#880000">//估值 —— 三目简写</span>
        mirrorCamera.fieldOfView = mirrorCamera.aspect >= <span style="color:#006666">1.0</span> ? Mathf.Rad2Deg * Mathf.Atan(((pb - pa).magnitude + (pc - pa).magnitude) / va.magnitude) : Mathf.Rad2Deg / mirrorCamera.aspect * Mathf.Atan(((pb - pa).magnitude + (pc - pa).magnitude) / va.magnitude);
        <span style="color:#880000">//在摄像机角度考虑,保证视锥足够宽</span>
    }
}</code></span>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156

3

Main Camera —— 主相机脚本(方便看到测试效果)

 


4

Create Cube —— 创建一个立方体


为了看镜子的效果

在场景中创建一个 Cube —— 用来作为参照对象

然后点击运行后,即可看到镜子效果已经完成 

 


5

Indistinct —— 显示效果不清晰


如果发现,镜子的显示效果并不清晰

这是因为我们创建的 Render Texture 时使用的是默认的分辨率 256*256

修改成较高的分辨率即可,这里我修改为:1024*1024 (可视情况自己设定)

Unity中用Shader实现镜子效果 做项目的时候要用到镜子,折腾了一下午,发现做镜子还是蛮快的,总结了一下网上的教程,大致有这么几种做法: 1、使用反射探针(Reflection Probe) 2、使用Render Texture 3、使用Shader着色器,我发现这种方法步骤比较少,而且重复使用起来也方便 下面就介绍一下这个方法,以及期间我踩过的坑;官方的教程在这里:MirrorReflection4 (我之所以说比较简... 阅读详情

相关推荐

Unity镜子效果的实现(无需镜子Shader)

Unity镜子效果制作教程 本文提供全流程,中文翻译。 Chinar 坚持将简单的生活方式,带给世人!(拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例) Chinar —— 心分享、心创新!助力快速实现一个简单的镜面反射效果为新手节省宝贵的时间,避免采坑! Chinar 教程效果: 1 Cre...

weixin_33947521的博客 9564

Unity3D 实现镜头模糊效果[Shader]

转自:http://www.manew.com/thread-98523-1-1.html shader代码:CameraFilterPack_Blur_Movie.shader Shader "CameraFilterPack/Blur_Movie" { Properties { _MainTex ("Base (RG...

GGman的博客 4807

[Unity] 利用RenderTexture与Camera实现镜子效果

[Unity] 利用RenderTexture与Camera实现镜子效果

连连看爱好者 1475

Unity 3D用简单的Cube、Sphere实现镜面/哈哈镜效果,只需十几秒哦!

Unity 3D用简单的Cube、Sphere实现镜面/哈哈镜效果,只需十几秒哦! Unity实现镜面和哈哈镜效果,本文提供全流程,中文翻译。 助力快速用 Cube 和 Sphere 完成镜面效果 由于制作过程过于简单 本教程仅用 Unity 提供的标准 Shader ,来实现仅反射天空盒周边环境的镜面效果 如果需要实现真实镜面,反射所有物体,可直接关闭本博文 等待,我今后的博客会有讲到。谢谢,理解!

Chinar优快云的博客 4551

Unity镜子shader的应用

有时候会使用到镜子的功能或者倒影的功能,看具体情况需要吧以上就是今天要讲的内容,本文仅仅简单介绍了镜子shader的应用.有需要会在补充的,本次就这么多了。

心疼你的一切博客 2206

Unity Shader 之 Render Texture 实现简单的镜子镜面效果

Unity Shader 之 Render Texture 实现简单的镜子镜面效果 目录 Unity Shader 之 Render Texture 实现简单的镜子镜面效果 一、简单介绍 二、实现原理 三、注意事项 四、效果预览 五、实现步骤 六、 代码 一、简单介绍 Shader Language的发展方向是设计出在便携性方面可以和C++、Java等相比的高...

仙魁XAN 2664

Unity镜子效果镜面反射效果无需Shader实现资源

Unity镜子效果镜面反射效果无需Shader实现资源 去发现同类优质开源项目:https://gitcode.com/ Unity游戏开发中,实现高质量的视觉效果通常需要复杂的Shader技术,但这并非易事。今天,我们要介绍一款开源项目——Unity镜子效果镜面反射效果(无需Shader)实现资源,它让开发者可以轻松创建出逼真的镜子效果。 项目介绍 Unity镜子效果镜面反射效果(无需Shade...

gitblog_06747的博客 995

Unity镜子效果、镜面反射效果(无需Shader)即可实现

无需自己找镜子Shader,只需2个脚本即可在Unity中创建一个简单的模拟镜面反射效果。 使用教程链接:https://blog.youkuaiyun.com/Chinar优快云/article/details/80862999

Unity镜子效果、镜面反射效果(无需Shader)实现资源

Unity镜子效果、镜面反射效果(无需Shader)实现资源 去发现同类优质开源项目:https://gitcode.com/ 本仓库提供了一种无需复杂Shader即可在Unity中实现简单镜面反射效果的方法。通过两个脚本,开发者可以轻松创建出逼真的镜子效果。 资源简介 资源标题:Unity镜子效果、镜面反射效果(无需Shader)即可实现 资源描述:无需自己找镜子Shader,只需2个脚本即可...

gitblog_06731的博客 407

Ubuntu 26.04 本地安装 GitLab CE 完整教程(非 Docker 方式)

本文详细介绍了在Ubuntu 26.04系统上通过Omnibus包安装GitLab CE的完整流程。主要内容包括:环境准备(系统要求、依赖安装)、配置清华镜像源、执行安装命令、修改配置文件、服务管理命令以及常见问题解决方法。文章特别强调了内存要求(建议4GB以上)、首次登录密码获取、HTTPS安全配置等关键点,并提供了性能优化建议和安全设置指导。相比Docker方式,Omnibus安装具有性能更好、管理方便等优势,适合需要私有化部署GitLab的场景。

1369

计算机视觉——多视图几何

多视图几何1.前言1.1 多视图几何概念2. 基本原理2.1 对极几何2.2 基础矩阵2.2.1 基础矩阵推导2.2.2 求解基础矩阵3. 实验过程3.1 实验数据准备3.2 实验代码3.3 实验结果及分析4. 实验中遇到的问题 1.前言 1.1 多视图几何概念 多视图几何是利用在不同视点所拍摄图像间的关系,来研究照相机之间或者特征之间关系的一门科学。 多视图几何(Multiple View ...

RuiMa的博客 7715

Unity 镜子效果

1Create Mirror —— 创建镜子 本教程,无需自己找镜子Shader,只需2个脚本即可在Unity中创建一个简单的模拟镜面反射效果 1. 在场景中创建一个 Plane —— 用来作为镜子 2. 同时创建一个材质球 /Material —— 给到 Plane 上 3. 修改新创建的 Material 的 Shader 为 Unlit/Texture 2Creat...

weixin_30663471的博客 473

GLDAS数据高效处理指南:基于Matlab的NC4转GeoTIFF实战解析

本文提供了一份基于Matlab的GLDAS数据处理实战指南,详细解析了如何将NetCDF4格式的GLDAS数据高效、准确地批量转换为GIS友好的GeoTIFF格式。文章核心内容包括数据理解、环境搭建、核心代码逐步拆解、效率提升技巧以及常见避坑方案,旨在帮助全球生态、水文与气候领域的研究者打通数据预处理的关键环节,提升科研工作效率。

weixin_29094775的博客 310

Unity镜子效果实现:RenderTexture与辅助相机方案完全解析

在Unity开发中实现镜面反射,很多开发者第一反应是编写复杂的Shader进行反射计算。然而,通过RenderTexture结合辅助相机的方案,开发者无需依赖Shader即可获得真实感极强的镜子效果。该方案将反射过程前置到相机渲染阶段,利用镜像矩阵将主相机位置关于镜面进行对称映射,辅助相机将场景渲染至RenderTexture,最终作为纹理贴图显示于镜面材质上。这种实现方式原理直观、管线兼容性好,适用于后视镜、试衣镜、监控大屏等场景。同时深入解析了RenderTexture参数配置、镜像旋转处理、斜视锥体裁

weixin_33849215的博客 243

合宙Air780EP速连OneNET:AT+MQTT应用指南

本文详细讲解了合宙Air780EP使用AT指令通过MQTT接入OneNET的过程。

2401_82812461的博客 1388

EEMD算法原理及应用

本博客主要概括EEMD算法的背景、原理以及应用,利用EEEMD对信号进行分解,然后选择有用的IMF分量进行叠加以完成信号的重构,从而实现对信号降噪。本文配套的源代码见文中链接,可供大家免费下载。

总结论文中的算法并给出论文的复现代码 4万+

Unity 快速实现镜子效果

一、快速搭建一个简单拿的场景 如图,白色的Quad即当作镜子。 二、使用相机纹理 创建一个相机,放到和镜子相同的位置(根据具体效果微调),再新建一个renderTexture,链接到相机的TargetTexture,并赋给镜子的材质球当纹理贴图,如下就能把摄像机拍摄到的东西显示在镜子上。 三、实现镜面效果 我们现实中的镜子是左右反向的,所以要对现有纹理进行UV的反向处理。 为了...

YasinXin的博客 9499

“华为杯”研究生数学建模竞赛2020年-【华为杯】E题:能见度估计与预测(附获奖论文及python代码实现)

因此,题目要求借助机场的 AMOS 观测数据中的气压、温度、湿度、风速等气象因子,达到 100% 时,空气中的水汽便会凝结成细微的水滴悬浮于空中,使地面水平的能见度下。传统的仪器探测法成本高,覆盖范围小,而基于视频的能见度检测能弥补仪器测量的不足之处,但是预测精度不高,需要进一步改。象条件,空气质量的影响,其中较为关键的影响因子是雾和霾。性过强,激光能见度仪的检测方法更为可信,但是激光能见度仪覆盖的检测范围小,安装。覆盖的交通视频路况数据间接计算得到能见度数值的方法,此方法成本较低,覆盖范围广。

getusushu的博客 2280

【Unity Shader】渲染纹理实现镜子效果

简单介绍了一下渲染纹理,并利用渲染纹理在Unity中实现了镜子效果。

qq_41835314的博客 2993

【OpenFOAM】-olaFlow-算例1- baseWaveFlume

算例文件注释--olaFlow-算例1- baseWaveFlume

ou_no的博客 3639

【系统分析师】2025年下半年真题:案例分析-答案及详解(回忆版)

Redis相比Memcached在电商高并发场景下具有显著优势:支持持久化(RDB/AOF)、丰富数据结构(如有序集合实现排行榜)、原生支持集群和哨兵模式(高可用性)。布隆过滤器通过位数组和哈希函数预先存储所有合法订单ID,当查询请求到达时快速拦截无效ID(如伪造ID),避免其穿透缓存直接冲击数据库,从而预防缓存击穿问题。

数据知道的博客 5982
上一篇: Unity中的法线贴图、漫反射及高光
下一篇: Unity 编辑器扩展
慕飞
博客等级 码龄11年 43粉丝 15原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值