Imported Alexander Ocias' solution for pixel-perfect 2D

Created a new scene to test it

Author: ciro-unity

Assets/Ocias.meta

@@ -0,0 +1,52 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+[CustomEditor(typeof(PixelArtCamera))]
+public class PixelArtCameraEditor : Editor {
+	SerializedProperty pixels;
+	SerializedProperty pixelsPerUnit;
+	SerializedProperty smooth;
+	SerializedProperty forceSquarePixels;
+
+	SerializedProperty screenResolution;
+	SerializedProperty upscaledResolution;
+	SerializedProperty internalResolution;
+	SerializedProperty finalBlitStretch;
+
+	SerializedProperty mainCamera;
+	SerializedProperty mainCanvas;
+	
+	void OnEnable () {
+		pixels = serializedObject.FindProperty("pixels");		
+		pixelsPerUnit = serializedObject.FindProperty("pixelsPerUnit");
+		smooth = serializedObject.FindProperty("smooth");
+		forceSquarePixels = serializedObject.FindProperty("forceSquarePixels");
+		screenResolution = serializedObject.FindProperty("screenResolution");
+		upscaledResolution = serializedObject.FindProperty("upscaledResolution");
+		internalResolution = serializedObject.FindProperty("internalResolution");
+		finalBlitStretch = serializedObject.FindProperty("finalBlitStretch");
+		mainCamera = serializedObject.FindProperty("mainCamera");
+		mainCanvas = serializedObject.FindProperty("mainCanvas");
+	}
+
+	public override void OnInspectorGUI() {
+		serializedObject.Update();
+
+		//GUILayout.Label ("Smooth");
+		DrawDefaultInspector ();
+		pixels.vector2IntValue = EditorGUILayout.Vector2IntField("Target Pixel Dimensions", pixels.vector2IntValue);
+		pixelsPerUnit.floatValue = EditorGUILayout.FloatField("Pixels Per Unit", pixelsPerUnit.floatValue);
+		smooth.boolValue = EditorGUILayout.Toggle("Smooth", smooth.boolValue);
+		forceSquarePixels.boolValue = EditorGUILayout.Toggle("Force Square Pixels", forceSquarePixels.boolValue);
+		EditorGUILayout.LabelField("Screen: " + screenResolution.vector2IntValue.x + "×" + screenResolution.vector2IntValue.y);
+		EditorGUILayout.LabelField("Pixel Resolution: " + internalResolution.vector2IntValue.x + "×" + internalResolution.vector2IntValue.y);
+		EditorGUILayout.LabelField("Upscaled Resolution: " + upscaledResolution.vector2IntValue.x + "×" + upscaledResolution.vector2IntValue.y);
+		Vector2 pixelSize = Vector2.zero;
+		pixelSize.x = (float)screenResolution.vector2IntValue.x / (float)internalResolution.vector2IntValue.x / finalBlitStretch.vector2Value.x;
+		pixelSize.y = (float)screenResolution.vector2IntValue.y / (float)internalResolution.vector2IntValue.y / finalBlitStretch.vector2Value.y;
+		EditorGUILayout.LabelField("Pixel Scale: " + pixelSize.x + "×" + pixelSize.y);
+
+		serializedObject.ApplyModifiedProperties ();
+	}
+}

Assets/Ocias/PixelArtCamera.meta

@@ -0,0 +1,154 @@
+// Ppppperfect pixel art rendering!!
+// By Alexander Ocias
+// https://ocias.com
+
+using UnityEngine;
+using UnityEngine.UI;
+
+[ExecuteInEditMode]
+public class PixelArtCamera : MonoBehaviour {
+	[HideInInspector] public Vector2Int screenResolution;
+	[HideInInspector] public Vector2Int internalResolution;
+	[HideInInspector] public Vector2Int upscaledResolution;
+	//[SerializeField] bool windowboxing = false; //Maybe implement this later?
+	[HideInInspector] public bool smooth = false;
+	[HideInInspector] public bool forceSquarePixels = false;
+	[HideInInspector] public Vector2Int pixels = new Vector2Int(1080/12, 1920/12);
+	[HideInInspector] public float pixelsPerUnit = 100f;
+	RenderTexture rt;
+
+	float targetAspectRatio;
+	float currentAspectRatio;
+	
+	[HideInInspector] public Vector2 finalBlitStretch = Vector2.one;
+
+	public Camera mainCamera;
+	public Canvas mainCanvas;
+
+	// Use this for initialization
+	void Start () {
+		SetupRenderTexture();
+	}
+
+	void Reset () {
+		// Try to connect everything automatically on first attach
+		mainCamera = Camera.main;
+		GameObject canvasObj = GameObject.Find("Canvas");
+		if (canvasObj != null) {
+			mainCanvas = canvasObj.GetComponent<Canvas>();
+		}
+	}
+
+	public void SetupRenderTexture () {
+		// Try to connect missing pieces
+		if (mainCamera == null) {
+			mainCamera = Camera.main;
+		}
+		if (mainCanvas != null) {
+			GameObject canvasObj = GameObject.Find("Canvas");
+			if (canvasObj != null) {
+				mainCanvas = canvasObj.GetComponent<Canvas>();
+			}
+		}
+		// prevent 0-size rendertextures, just in case
+		if (pixels.x == 0 || pixels.y == 0) {
+			return;
+		}
+		// Configure canvas properly to match camera
+		if (mainCanvas != null) {
+			mainCanvas.renderMode = RenderMode.ScreenSpaceCamera;
+			mainCanvas.worldCamera = mainCamera;
+			CanvasScaler scaler = mainCanvas.GetComponent<CanvasScaler>();
+			scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+			scaler.referenceResolution = new Vector2(pixels.x, pixels.y);
+			scaler.screenMatchMode = CanvasScaler.ScreenMatchMode.Expand;
+			scaler.referencePixelsPerUnit = pixelsPerUnit;
+		}
+		
+		if (rt != null) {
+			rt.Release();
+		}
+		
+		screenResolution.x = Screen.width;
+		screenResolution.y = Screen.height;
+
+		targetAspectRatio = (float)pixels.x / (float)pixels.y;
+		currentAspectRatio = (float)Screen.width / (float)Screen.height;
+		
+		internalResolution.x = pixels.x;
+		internalResolution.y = pixels.y;
+		
+		// Figure out best pixel resolution for aspect ratio we're on
+		if (currentAspectRatio != targetAspectRatio) {
+			if (currentAspectRatio > targetAspectRatio) {
+				// Wider screen
+				internalResolution.x = (int)Mathf.Round((float)pixels.y * currentAspectRatio);
+			} else {
+				// Taller screen
+				internalResolution.y = (int)Mathf.Round((float)pixels.x / currentAspectRatio);
+			}
+		}
+		
+		// Determine scale to keep pixels square
+		finalBlitStretch = Vector2.one;
+		if (forceSquarePixels) {
+			float internalResAspect = (float)internalResolution.x / (float)internalResolution.y;
+			if (currentAspectRatio != targetAspectRatio) {
+				if (currentAspectRatio > targetAspectRatio) {
+					// Wider screen
+					finalBlitStretch.x = (currentAspectRatio / internalResAspect);
+				} else {
+					// Taller screen
+					finalBlitStretch.y = (internalResAspect / currentAspectRatio);
+				}
+			}
+		}
+
+		// Make sure our camera projection fits our resolution
+		mainCamera.orthographicSize = internalResolution.y / 2f / pixelsPerUnit;
+
+		rt = new RenderTexture(internalResolution.x, internalResolution.y, 16, RenderTextureFormat.ARGB32);
+		
+		if (smooth) {
+			rt.filterMode = FilterMode.Bilinear;
+		} else {
+			rt.filterMode = FilterMode.Point;
+		}
+		rt.Create();
+	}
+
+	void OnPreRender() {
+		if ((float)Screen.width / (float)Screen.height != currentAspectRatio) {
+			SetupRenderTexture();
+		}
+		if (mainCamera != null) {
+			// Render to our small internal texture
+			mainCamera.targetTexture = rt;
+		}
+    }
+	void OnPostRender() {
+		if (mainCamera == null) {
+			return;
+		}
+		// null the targettexture so we can blit to the screen
+		mainCamera.targetTexture = null;
+		
+		if (smooth) {
+			Graphics.Blit(rt, null, finalBlitStretch, (finalBlitStretch - Vector2.one) / -2f);
+		} else {
+			// draw to buffer at least as big as the screen
+			int scaleMultiple = Mathf.CeilToInt((float)Screen.width / (float)internalResolution.x);
+			upscaledResolution.x = internalResolution.x * scaleMultiple;
+			upscaledResolution.y = internalResolution.y * scaleMultiple;
+			RenderTexture largeRt = RenderTexture.GetTemporary(upscaledResolution.x, upscaledResolution.y);
+			Graphics.Blit(rt, largeRt);
+			
+			// Scale down to screen		
+			Graphics.Blit(largeRt, null, finalBlitStretch, (finalBlitStretch - Vector2.one) / -2f);
+			RenderTexture.ReleaseTemporary(largeRt);
+		}
+		
+    }
+}
+
+

Assets/Ocias/PixelArtCamera/Editor.meta

@@ -0,0 +1,84 @@
+// Simplified Diffuse shader. Differences from regular Diffuse one:
+// - no Main Color
+// - fully supports only 1 directional light. Other lights can affect it, but it will be per-vertex/SH.
+
+Shader "Ocias/Pixel Art Diffuse" {
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "white" {}
+}
+SubShader {
+	Tags { "RenderType"="Opaque" }
+	LOD 150
+
+CGPROGRAM
+#pragma surface surf Lambert vertex:vert noforwardadd
+
+sampler2D _MainTex;
+
+struct Input {
+	float2 uv_MainTex;
+};
+
+inline float4 ViewSpacePixelSnap (float4 pos) {
+
+	float2 halfScreenRes = _ScreenParams.xy * 0.5f;
+
+	// // View space Pixel Snapping
+	float2 pixelPos = floor(pos * halfScreenRes + 1 / halfScreenRes) / halfScreenRes; // put back in that half pixel offset when you're done
+	pos.xy = pixelPos;
+	
+	// Odd resolution handling
+	// float2 odd = _ScreenParams.xy % 2;
+	// pos.x += odd.x * 0.5 / halfScreenRes.x;
+	// pos.y += odd.y * 0.5 / halfScreenRes.y;
+
+	return pos;
+}
+
+inline float4 WorldSpacePixelSnap (float4 pos) {
+
+	//float ppu = _PixelsPerUnit;
+	float zoom = 1/(unity_CameraProjection[1][1]);
+	float ppu = _ScreenParams.y / zoom / 2;
+
+	pos = mul(unity_ObjectToWorld, pos);
+	
+	// World space Pixel Snapping
+	pos = floor(pos * ppu + 1 / ppu) / ppu;
+	// Adjust to pixel relative to camera position
+	float3 snappedCameraPosition = floor(_WorldSpaceCameraPos * ppu + 1 / ppu) / ppu;
+	float3 cameraSubpixelOffset = snappedCameraPosition - _WorldSpaceCameraPos;
+	pos.x -= cameraSubpixelOffset.x;
+	pos.y -= cameraSubpixelOffset.y;
+	// Odd resolution handling
+	float2 odd = round(_ScreenParams.xy) % 2;
+	pos.x += odd.x * 0.5 / ppu;
+	pos.y += odd.y * 0.5 / ppu;
+
+	pos = mul(unity_WorldToObject, pos);
+
+	return pos;
+}
+
+void vert (inout appdata_full v) {
+	// Offset position based on distance from camera to nearest pixel
+	// float zoom = 1/(unity_CameraProjection[1][1]);
+	// float ppu = _ScreenParams.y / zoom / 2;
+	// float3 snappedCameraPosition = floor(_WorldSpaceCameraPos * ppu + 1 / ppu) / ppu;
+	// float3 cameraSubpixelOffset = snappedCameraPosition - _WorldSpaceCameraPos;
+	// v.vertex.x -= cameraSubpixelOffset.x;
+	// v.vertex.y -= cameraSubpixelOffset.y;
+
+	v.vertex = WorldSpacePixelSnap(v.vertex);
+}
+
+void surf (Input IN, inout SurfaceOutput o) {
+	fixed4 c = tex2D(_MainTex, IN.uv_MainTex);
+	o.Albedo = c.rgb;
+	o.Alpha = c.a;
+}
+ENDCG
+}
+
+Fallback "Mobile/VertexLit"
+}

Assets/Ocias/PixelArtCamera/Editor/PixelArtCameraEditor.cs

@@ -0,0 +1,33 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: PixelArtFont
+  m_Shader: {fileID: 4800000, guid: 81779508cd63b403fb890fd1e517d5ab, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _ColorMask: 15
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}