Unity Version: 5.2.2f1 Personal
First of all, I’m not an expert in shaders.
I’ve found a way of doing this by using a shader that modified and combined excerpts from other shader scripts I found online, the sources of which are on the first lines of the shader. The result shown here is from a (2, 2, 2) sized cube from unity.

To apply this to your cube you need to create a file with this shader and used this in your material. The shader used is this:
// Part of the Shader was created by Alastair Aitchison (url: https://alastaira.wordpress.com)
// Some parts come from https://en.wikibooks.org/wiki/Cg_Programming/Unity/Lighting_Textured_Surfaces
// Some parts come from https://en.wikibooks.org/wiki/Cg_Programming/Unity/Transparency
Shader "Custom/PerspectiveView" {
Properties{
[Header(Material)]
_MainTex ("Texture For Diffuse Material Color", 2D) = "white" {}
_Color ("Color", Color) = (1.0, 1.0, 1.0, 1.0)
_SpecColor ("Specular Material Color", Color) = (1,1,1,1)
_Shininess ("Shininess", Float) = 10
}
SubShader{
Tags {"LightMode" = "ForwardBase"}
Tags {"Queue" = "Transparent"}
Pass{
Blend SrcAlpha OneMinusSrcAlpha // use alpha blending
CGPROGRAM
// Pragmas
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
uniform fixed4 _LightColor0;
// User defined variables
uniform sampler2D _MainTex;
uniform fixed4 _Color;
uniform fixed4 _SpecColor;
uniform half _Shininess;
struct VertexInput{
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 texcoord : TEXCOORD0;
};
struct VertexOutput{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
fixed3 diffuseColor : TEXCOORD1;
fixed3 specularColor : TEXCOORD2;
};
VertexOutput vert(VertexInput v){
VertexOutput o;
// Perspective Section
//-------------------------------------------------------------------
//
// Transform the vertex coordinates from model space into world space
float4 vv = mul( _Object2World, v.vertex);
// Now adjust the coordinates to be relative to the camera position
vv.xyz += _WorldSpaceCameraPos.xyz;
if(vv.y > 0)
vv.y = vv.z - _WorldSpaceCameraPos.z;
else
vv.y = _WorldSpaceCameraPos.z - vv.z - 2;
if(vv.x > 0)
vv.x = vv.z - _WorldSpaceCameraPos.z;
else
vv.x = _WorldSpaceCameraPos.z - vv.z - 2;
/*if(vv.z > _WorldSpaceCameraPos.z)
vv = float4(vv.x - _WorldSpaceCameraPos.x, vv.y - _WorldSpaceCameraPos.y, 0.0f, 0.0f);
else
vv = float4(0.0f, 0.0f, 0.0f, 0.0f);*/
// Now apply the offset back to the vertices in model space
v.vertex += mul(_World2Object, vv);
o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
// Light Section
//-------------------------------------------------------------------
//
// multiplication with unity_Scale.w is unnecessary
// because we normalize transformed vectors
float3 normalDirection = normalize(mul(float4(v.normal, 0.0), _World2Object).xyz);
float3 viewDirection = normalize(_WorldSpaceCameraPos - mul(_Object2World, v.vertex).xyz);
float3 lightDirection;
float attenuation;
if (0.0 == _WorldSpaceLightPos0.w) // directional light?
{
attenuation = 1.0; // no attenuation
lightDirection = normalize(_WorldSpaceLightPos0.xyz);
}
else // point or spot light
{
float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - mul(_Object2World, v.vertex).xyz;
float distance = length(vertexToLightSource);
attenuation = 1.0 / distance; // linear attenuation
lightDirection = normalize(vertexToLightSource);
}
float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;
float3 diffuseReflection = attenuation * _LightColor0.rgb * _Color.rgb * max(0.0, dot(normalDirection, lightDirection));
float3 specularReflection;
if (dot(normalDirection, lightDirection) < 0.0)
// light source on the wrong side?
{
specularReflection = float3(0.0, 0.0, 0.0);
// no specular reflection
}
else // light source on the right side
{
specularReflection = attenuation * _LightColor0.rgb * _SpecColor.rgb * pow(max(0.0, dot(reflect(-lightDirection, normalDirection), viewDirection)), _Shininess);
}
o.diffuseColor = ambientLighting + diffuseReflection;
o.specularColor = specularReflection;
o.tex = v.texcoord;
return o;
}
fixed4 frag(VertexOutput i) : COLOR {
return fixed4(i.specularColor + i.diffuseColor * tex2D(_MainTex, i.tex.xy), _Color.a);
}
ENDCG
}
}
}
As I said before, this is a combination of multiple shaders I found online and the part that creates the perspective effect in this cube is presented below. As for adjusting it to a cube of a different size or to another model, it’s probably doable by changing the shader in that part. There’s another restriction to this shader which is the fact that the result depends on the camera position, this was done while the camera was at (-0.5, -0.5, -10) with a rotation of (0, 0, 0), by changing these values you’ll get different results.
I take the opportunity to ask for some suggestions on how to improve and generalize this shader for all models, with no restrictions.
// Perspective Section
//-------------------------------------------------------------------
//
// Transform the vertex coordinates from model space into world space
float4 vv = mul( _Object2World, v.vertex);
// Now adjust the coordinates to be relative to the camera position
vv.xyz += _WorldSpaceCameraPos.xyz;
if(vv.y > 0)
vv.y = vv.z - _WorldSpaceCameraPos.z;
else
vv.y = _WorldSpaceCameraPos.z - vv.z - 2;
if(vv.x > 0)
vv.x = vv.z - _WorldSpaceCameraPos.z;
else
vv.x = _WorldSpaceCameraPos.z - vv.z - 2;
/*if(vv.z > _WorldSpaceCameraPos.z)
vv = float4(vv.x - _WorldSpaceCameraPos.x, vv.y - _WorldSpaceCameraPos.y, 0.0f, 0.0f);
else
vv = float4(0.0f, 0.0f, 0.0f, 0.0f);*/
// Now apply the offset back to the vertices in model space
v.vertex += mul(_World2Object, vv);
o.pos = mul(UNITY_MATRIX_MVP, v.vertex);