Unity残影

可以用两种方式实现残影：1. 新建一个Mesh，记录前几帧的人物的影像，然后通过后处理混合上去。2.记录前几帧的人物位置，将其传入shader中，对每个位置进行一个pass渲染。

第一方式

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

public class AfterImage : MonoBehaviour
{
List<List<GameObject>> _meshGoList = new List<List<GameObject>>();
List<SkinnedMeshRenderer> _renderList= new List<SkinnedMeshRenderer>();
Shader _curShader;
Shader CurShader
{
get
{
if(_curShader == null)
{
_curShader = Shader.Find("Custom/AfterImage");
}
return _curShader;
}
}
// Use this for initialization
void Start ()
{
var renders = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
_renderList.AddRange(renders);
}

int num = 1;
int max = 5;
float interval = 0.1f;
float deltaTime = 0;
private void DeEffect()
{
List<GameObject> meshList = new List<GameObject>();
for(int i = 0; i < _renderList.Count; ++i)
{
string meshName = string.Format("meshName_{0}_{1}", num, i);
GameObject meshGo = new GameObject(meshName);
meshGo.transform.position = _renderList[i].gameObject.transform.position;
meshGo.transform.localRotation = _renderList[i].gameObject.transform.localRotation;
Mesh mesh = new Mesh();
_renderList[i].BakeMesh(mesh);
MeshFilter meshFilter = meshGo.AddComponent<MeshFilter>();
meshFilter.mesh = mesh;
MeshRenderer skin = meshGo.AddComponent<MeshRenderer>();
skin.material = GetMaterial(_renderList[i].material);
//            skin.material = _renderList[i].material;
meshList.Add(meshGo);
}
_meshGoList.Add(meshList);
num += 1;
}

private Material GetMaterial(Material mat)
{
Material nMat = new Material(CurShader);
nMat.SetTexture("_MainTex", mat.mainTexture);
return nMat;
}

// Update is called once per frame
void Update ()
{
if (deltaTime >= interval)
{
DeEffect();
deltaTime = 0f;
}
else
{
deltaTime += Time.deltaTime;
}

if(_meshGoList.Count > 5)
{
for(int i = 0; i < _meshGoList.Count - max; ++i)
{
if(_meshGoList[i] != null)
{
for(int j = 0; j < _meshGoList[i].Count; ++j)
{
if(_meshGoList[i][j] != null)
{
DestroyImmediate(_meshGoList[i][j]);
}
}
}
}

for(int i = 0; i < _meshGoList.Count - max; ++i)
{
_meshGoList.RemoveAt(0);
}
}
}
}

Shader "Custom/AfterImage"
{
Properties
{
_Color ("Color", Color) = (1,0.8,1,0.5)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
}
SubShader {
Tags {"Queue" = "Transparent" "LightMode" = "Always" "RenderType"="Opaque"}

Pass
{
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
sampler2D _MainTex;
fixed4 _Color;
struct v2f
{
float4 pos : SV_POSITION;
float2 uv : TEXCOORD0;
};

v2f vert( appdata_base v)
{
v2f o;
o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
o.uv = v.texcoord;
return o;
}

fixed4 frag(v2f i) : COLOR
{
float4 c;
c = tex2D(_MainTex, i.uv);
c = c * _Color;
return c;
}
ENDCG
}

}
FallBack "Diffuse"
}

把这个脚本挂到要产生残影的物体上就可以看到残影了
第二种方法(主要参考http://www.cnblogs.com/foxianmo/p/4946116.html?utm_source=tuicool&utm_medium=referral)

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

public class Ghost : MonoBehaviour {
public Shader curShader;
private List<Vector3> offsets = new List<Vector3>();
private List<Material> mats = new List<Material>();
// Use this for initialization
void Start ()
{
offsets.Add(transform.position);
offsets.Add(transform.position);
offsets.Add(transform.position);
offsets.Add(transform.position);

var skinMeshRenderer = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
foreach(var mr in skinMeshRenderer)
{
mats.Add(mr.material);
}

foreach(var mat in mats)
{
mat.shader = curShader;
}
}

// Update is called once per frame
void Update ()
{
foreach(var mat in mats)
{
mat.SetVector("_Offset0", offsets[3] - transform.position);
mat.SetVector("_Offset1", offsets[2] - transform.position);
mat.SetVector("_Offset2", offsets[1] - transform.position);
mat.SetVector("_Offset3", offsets[0] - transform.position);
}
offsets.Add(transform.position);
offsets.RemoveAt(0);
}
}

Shader "Custom/Ghosh" {
Properties {
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Offset0("Offset 0", vector) = (0, 0, 0, 0)
_Offset1("Offset 1", vector) = (0, 0, 0, 0)
_Offset2("Offset 2", vector) = (0, 0, 0, 0)
_Offset3("Offset 3", vector) = (0, 0, 0, 0)
}

CGINCLUDE
#include "UnityCG.cginc"

sampler2D _MainTex;
float4 _Offset0;
float4 _Offset1;
float4 _Offset2;
float4 _Offset3;

struct v2f
{
float4 pos : POSITION;
float2 uv : TEXCOORD0;
};

v2f vert_normal( appdata_base v)
{
v2f o;
o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
o.uv = v.texcoord;
return o;
}

v2f vert_offset_1( appdata_base v)
{
v2f o;
float4 pos = mul(_Object2World, v.vertex);
o.pos = mul(UNITY_MATRIX_VP, pos + _Offset0);
o.uv = v.texcoord;
return o;
}

v2f vert_offset_2( appdata_base v)
{
v2f o;
float4 pos = mul(_Object2World, v.vertex);
o.pos = mul(UNITY_MATRIX_VP, pos + _Offset1);
o.uv = v.texcoord;
return o;
}

v2f vert_offset_3( appdata_base v)
{
v2f o;
float4 pos = mul(_Object2World, v.vertex);
o.pos = mul(UNITY_MATRIX_VP, pos + _Offset2);
o.uv = v.texcoord;
return o;
}

v2f vert_offset_4( appdata_base v)
{
v2f o;
float4 pos = mul(_Object2World, v.vertex);
o.pos = mul(UNITY_MATRIX_VP, pos + _Offset3);
o.uv = v.texcoord;
return o;
}

float4 frag_normal(v2f i) : COLOR
{
return tex2D(_MainTex, i.uv);
}

float4 frag_color(v2f i) : COLOR
{
float4 c;
c = tex2D(_MainTex, i.uv);
c.w = 0.5;
return  c;
}
ENDCG

SubShader
{
Pass
{
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert_offset_4
#pragma fragment frag_color
ENDCG
}

Pass
{
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert_offset_3
#pragma fragment frag_color
ENDCG
}

Pass
{
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert_offset_2
#pragma fragment frag_color
ENDCG
}

Pass
{
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert_offset_1
#pragma fragment frag_color
ENDCG
}

Pass
{
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert_normal
#pragma fragment frag_normal
ENDCG
}
}
FallBack "Diffuse"
}

同样是把脚本挂到要产生残影的物体上就可以看到残影

个人比较喜欢第一种方法，第二种方法要更改原物体的shader，要同时存在几种效果的时候会变得很麻烦