需要写代码实现：

using UnityEngine; 

using System.Collections;

 [ExecuteInEditMode] 

public class CameraPixelate : MonoBehaviour 

{   

 [SerializeField, RangeAttribute(0.001f, 1)]   

 private float scale = 1;  

  void OnRenderImage(RenderTexture sourceTexture, RenderTexture destTexture)  

  {        RenderTexture temp = RenderTexture.GetTemporary((int)(sourceTexture.width * scale), (int)(sourceTexture.width * scale), 0, sourceTexture.format);        temp.filterMode = FilterMode.Point;        Graphics.Blit(sourceTexture, temp);        Graphics.Blit(temp, destTexture);        RenderTexture.ReleaseTemporary(temp);    } }

Shader "ImageRepeat"

{

Properties

{

_mainTexture("mainTexture", 2D) = "white" {}

_X("_X", Range( -1 , 1)) = -1

_Y("_Y", Range( -1 , 1)) = 0

}

SubShader

{

Tags { "RenderType"="Opaque" }

LOD 100

 

CGINCLUDE

#pragma target 3.0

ENDCG

Blend Off

Cull Back

ColorMask RGBA

ZWrite On

ZTest LEqual

Offset 0 , 0

Pass

{

Name "Unlit"

CGPROGRAM

#ifndef UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX

//only defining to not throw compilation error over Unity 5.5

#define UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)

#endif

#pragma vertex vert

#pragma fragment frag

#pragma multi_compile_instancing

#include "UnityCG.cginc"

 

struct appdata

{

float4 vertex : POSITION;

float4 color : COLOR;

UNITY_VERTEX_INPUT_INSTANCE_ID

float4 ase_texcoord : TEXCOORD0;

};

struct v2f

{

float4 vertex : SV_POSITION;

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

float4 ase_texcoord : TEXCOORD0;

};

 

uniform sampler2D _mainTexture;

uniform float4 _mainTexture_ST;

uniform float _X;

uniform float _Y;

v2f vert ( appdata v )

{

v2f o;

UNITY_SETUP_INSTANCE_ID(v);

UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

UNITY_TRANSFER_INSTANCE_ID(v, o);

 

o.ase_texcoord.xy = v.ase_texcoord.xy;

//setting value to unused interpolator channels and avoid initialization warnings

o.ase_texcoord.zw = 0;

float3 vertexValue =  float3(0,0,0) ;

#if ASE_ABSOLUTE_VERTEX_POS

v.vertex.xyz = vertexValue;

#else

v.vertex.xyz += vertexValue;

#endif

o.vertex = UnityObjectToClipPos(v.vertex);

return o;

}

fixed4 frag (v2f i ) : SV_Target

{

UNITY_SETUP_INSTANCE_ID(i);

UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);

fixed4 finalColor;

float2 uv0_mainTexture = i.ase_texcoord.xy * _mainTexture_ST.xy + _mainTexture_ST.zw;

float2 temp_cast_0 = (( ( uv0_mainTexture.x * _X ) + ( uv0_mainTexture.y * _Y ) )).xx;

finalColor = tex2D( _mainTexture, temp_cast_0 );

return finalColor;

}

ENDCG

}

哥们的Unity项目遇到了一个问题, 如果能做出像素旋转, 就可以节约很多时间.

曾经看到过一个似乎叫做 perfect pixel rotation 的插件, 穷学生还是溜了溜了...

在网络上搜了一些资料, 解决方法大多是改变摄像机分辨率...

额...不巧哥们的游戏是伪像素风, 像素大小不一, 只是个别地方需要像素旋转, 如果能写个Shader出来那真是极好的...

下面是shader代码以及一些说明.

Shader "Custom/PixelRotate" {
    Properties 
    {
        _MainTex ("Altitude Texture", 2D) = "white" {}
        _PixelRotate ("Mask Rotate", float) = 0
    }
    SubShader{
        Tags{"Queue"="Transparent" "RenderType"="Opaque" "IgnoreProject"="True"}
        Pass{
            Tags{"LightMode"="ForwardBase"}
 
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha
            Cull Off
 
            CGPROGRAM
   #pragma enable_d3d11_debug_symbols 
            #pragma vertex vert            #pragma fragment frag            #include "UnityCG.cginc"
            sampler2D _MainTex;
            float _PixelRotate;
            float4 _MainTex_TexelSize;
          
            struct a2v 
            {
                float4 vertex : POSITION;
                float4 texcoord : TEXCOORD0;
            };
            struct v2f 
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
            };
 
 
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord.xy;
                return o;
            }
            fixed4 frag(v2f i) : SV_Target
            {
             float pixelSize = _MainTex_TexelSize.x;
             float4x4 rotateMat = 
             {
              cos(_PixelRotate),-sin(_PixelRotate),0,0,
              sin(_PixelRotate),cos(_PixelRotate),0,0,
              0,0,1,0,
              0,0,0,1
             };
             float2 pixelCountf = i.uv/pixelSize.x;
             int2 pixelCount = int2(round(pixelCountf.x),round(pixelCountf.y));
             float2 delta = i.uv - pixelCount*pixelSize;
             i.uv -= delta;
             float2 uvAfterRotate = mul(rotateMat, i.uv-float2(0.5f,0.5f))+float2(0.5f,0.5f);
             return tex2D(_MainTex, uvAfterRotate);
            }
            ENDCG
        }
    }
    FallBack Off}

思路比较简单, 简单来讲就是让一个正方形像素内的uv能够取到同一种颜色, 像素大小通过_MainTex_TexelSize获得.

关键就是让uv以像素大小为单位取整, 然后旋转uv并取色.

(通过修改材质参数_PixelRotate 旋转...)

下面是shader代码以及一些说明.

Shader "Custom/PixelRotate" {
    Properties 
    {
        _MainTex ("Altitude Texture", 2D) = "white" {}
        _PixelRotate ("Mask Rotate", float) = 0
    }
    SubShader{
        Tags{"Queue"="Transparent" "RenderType"="Opaque" "IgnoreProject"="True"}
        Pass{
            Tags{"LightMode"="ForwardBase"}
 
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha
            Cull Off
 
            CGPROGRAM
   #pragma enable_d3d11_debug_symbols 
            #pragma vertex vert            #pragma fragment frag            #include "UnityCG.cginc"
            sampler2D _MainTex;
            float _PixelRotate;
            float4 _MainTex_TexelSize;
          
            struct a2v 
            {
                float4 vertex : POSITION;
                float4 texcoord : TEXCOORD0;
            };
            struct v2f 
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
            };
 
 
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord.xy;
                return o;
            }
            fixed4 frag(v2f i) : SV_Target
            {
             float pixelSize = _MainTex_TexelSize.x;
             float4x4 rotateMat = 
             {
              cos(_PixelRotate),-sin(_PixelRotate),0,0,
              sin(_PixelRotate),cos(_PixelRotate),0,0,
              0,0,1,0,
              0,0,0,1
             };
             float2 pixelCountf = i.uv/pixelSize.x;
             int2 pixelCount = int2(round(pixelCountf.x),round(pixelCountf.y));
             float2 delta = i.uv - pixelCount*pixelSize;
             i.uv -= delta;
             float2 uvAfterRotate = mul(rotateMat, i.uv-float2(0.5f,0.5f))+float2(0.5f,0.5f);
             return tex2D(_MainTex, uvAfterRotate);
            }
            ENDCG
        }
    }
    FallBack Off}

思路比较简单, 简单来讲就是让一个正方形像素内的uv能够取到同一种颜色, 像素大小通过_MainTex_TexelSize获得.

关键就是让uv以像素大小为单位取整, 然后旋转uv并取色.

(通过修改材质参数_PixelRotate 旋转...)