How to correctly get jaggy free pixel textures in 3D game?

When you change their size in photoshop, under image size make sure "Resample" is unchecked, you shouldn't get any resampling of the pixels upon changing the size that way.

Since bilinear interpolation naturally blends between every pixel across the entire length of those pixels, you'll need to write a shader which ignores that normal blending.

For this, you'll want to decide on your basis for calculation:

A) Manually interpolate pixels in a point-filtered texture (which requires no fewer than 4 pixels read), then adapt the blending itself.

B) Manipulate texture reads on an interpolated texture (1 pixel read, but more costly) to make it look like a point-filtered texture, then adapt the position of the read pixel.

This isn't complete, but should get you started in the right direction for approach B. Using an unlit shader as the baseline to keep it short:

 Shader "Unlit/FilterScale"
 {
     Properties
     {
         _MainTex ("Texture", 2D) = "white" {}
         _Threshold ("Rounding Threshold", Range(0.0, 1.0)) = 0.5
     }
     SubShader
     {
         Tags { "RenderType"="Opaque" }
         
         Pass
         {
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
             
             #include "UnityCG.cginc"
             
             struct appdata
             {
                 float4 vertex : POSITION;
                 float2 uv : TEXCOORD0;
             };
         
             struct v2f
             {
                 float2 uv : TEXCOORD0;
                 float4 vertex : SV_POSITION;
             };
             
             sampler2D _MainTex;
             float4 _MainTex_ST;
             float4 _MainTex_TexelSize;
             float _Threshold;
             
             v2f vert (appdata v)
             {
                 v2f o;
                 o.vertex = UnityObjectToClipPos    (v.vertex);
                 o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                 return o;
             }
             
             fixed4 frag (v2f i) : SV_Target
             {
                 // Half-pixel offset to grab the center of each pixel to disguise bilinear-filtered textures as point-sampled
                 float2 halfPixel = _MainTex_TexelSize.xy * 0.5;
                 // Location (0-1) on a given pixel for the current sample
                 float2 pixelPos = frac(i.uv * _MainTex_TexelSize.zw);
                 // sub-pixel position transformed into (-1 to 1) range from pixel center
                 pixelPos = pixelPos * 2.0 - 1.0;
                 float2 scale;
                 float2 absPixelPos = abs(pixelPos);
                 // If sub-pixel position is near an edge (_Threshold), use point-filtering (scale = 0)
                 // Otherwise, use an analog dead zone calculation to approximate blending
                 // (note: can be improved)
                 // http://www.third-helix.com/2013/04/12/doing-thumbstick-dead-zones-right.html
                 if(absPixelPos.x < _Threshold)
                 {
                     scale.x = 0.0;
                 }
                 else
                 {
                     scale.x = (absPixelPos.x - _Threshold) / (1.0 - _Threshold);
                 }
                 if (absPixelPos.y < _Threshold)
                 {
                     scale.y = 0.0;
                 }
                 else
                 {
                     scale.y = (absPixelPos.y - _Threshold) / (1.0 - _Threshold);
                 }
                 // Calculate the new real UV coordinate by blending between the center of the current pixel and the original sample position per axis
                 float2 uvCoord;
                 uvCoord.x = lerp(floor(i.uv.x * _MainTex_TexelSize.z) * _MainTex_TexelSize.x + halfPixel.x, i.uv.x, scale.x);
                 uvCoord.y = lerp(floor(i.uv.y * _MainTex_TexelSize.w) * _MainTex_TexelSize.y + halfPixel.y, i.uv.y, scale.y);
                 
                 float4 col = tex2D(_MainTex, uvCoord);
                 return col;
             }
             ENDCG
         }
     }
 }

_{I apologize that it's a little sloppy (I got the algorithm close enough to function well, but can't remember what I'm missing to make it just a little cleaner).}

I understand your question and why it looks good when filtered biliniear when the texture is saved in a much larger scale in photoshop. I'm looking for the same thing ;) Have you found an easy solution yet?

Some random thoughts on this subject. What you would like to have as a result is comparable with Antialiasing which is used to make geometry borders look more smoothly. But instead of cleaning up geometry borders you would like to perform this on textures between pixels. Technically I could understand why this is more gpu consuming then just using high res textures as a source. Maybe the textures could be upscaled when the game starts somehow. Or maybe render the whole game twice as high resolution as being displayed on screen. This is no way gpu friendly. I think you also get in trouble with mipmaps when using very low resolution textures.

So that are my random thought, I just hope like you there is an easy solution.