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).}