Difference between iOS and other platforms..

Unity Engine
1

Hi.

I’m trying to adjust a shader, but i’m curious why it does not render the same on iOS (make it less easy to tweak).
What am i doing wrong ?

My problem is somewhere near the specular power… so the light is too hard on iOs version.
The specular is filtered via the alpha component of _MainTex (pure grey here)

Shader "Test/SpecTest" 
{
    Properties 
    {
      _MainTex ("Diffuse", 2D) = "white" {}
      _BumpMap ("Bumpmap", 2D) = "bump" {}
      _SpecPower ("Spec Power", Range(0.5,100.0)) = 50.0
    }
    
    SubShader 
    {
	  Tags {"Queue" = "Transparent" }
	  
      CGPROGRAM
      
	  #pragma surface surf SimpleSpecular

      struct Input 
      {
        float2 uv_MainTex;
        float2 uv2_SecondTex;
      };
      
      sampler2D _MainTex;
      sampler2D _BumpMap;
      float _SpecPower;

      half4 LightingSimpleSpecular (SurfaceOutput s, half3 lightDir, half3 viewDir, half atten) 
      {
          half3 h = normalize (lightDir + viewDir);
          half diff = max (0, dot (s.Normal, lightDir));
          float nh = max (0, dot (s.Normal, h));
          float spec = pow (nh, _SpecPower);
          
          half4 c;
          c.rgb = (s.Albedo * diff * 0.5 + spec * s.Specular * 0.5) * (atten * 2);
          c.a = s.Alpha;
          return c;
      }
            
      void surf (Input IN, inout SurfaceOutput o) 
      {
        o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
	o.Specular = tex2D (_MainTex, IN.uv_MainTex).a;
        o.Normal = UnpackNormal (tex2D (_BumpMap, IN.uv_MainTex));
      }
      
      ENDCG
    } 
    Fallback "Diffuse"
  }

Edit : + Android versions look the same as iOS’s one (so only PC/Mac/Web render are as i’d like too).

780862--28520--$diff_check.jpg
780862--28520--$diff_check.jpg737×400 36 KB

2

It looks like you are using PVRTC to compress your normal map on iOS, which destroys a lot of information. Try turning compression off for iOS.

3

Sure, this is a quick and dirty version because i’m not allowed to show the reals assets.
My problem is in the light reaction… it’s smooth on pc/mac side, and it quickly burn white on iOs.

May be it’s not enough visible here, but for sure the reaction is different from a platform to another, and this sound strange no ?

4

Not needfully no.

Different platform, different gpu, different compression, different rendering paths → potentially different outcome.

In this case it could be something as simple as the choosen texture compression (desktop is DXT5NM, which is a format especially for normal maps, on mobiles there is no NM format so if you choose compressed you can easily achieve serious differences) but it could also be related to the light type and distance itself or the choosen precision within the shader code which makes a major difference on the resulting calculation.
As you feed the alpha channel for specularity though chances are very high that it is simply the texture compression which is much more destructive on mobile than desktop (DXTC / S3TC vs PVRTC), thats why daniel recommended comparing it without any texture compression, in case of specularity on the diffuse texture, to see if its really different or simply a consequence of compression artifacts

5

Ok thanks for the clarification (and thanks daniel for the first input). I’ll check without any compression on both sides.
But i’m quite sure it’s a difference in specular computation (shader precision or so…).

It must be a hard work, behind the curtain, to get same results on different platforms, but i think it’s part of Unity’s goal.
For now i’ll assume i need different shaders/parameters.

6

I’m pretty sure its specular too, thus the part on the ‘diffuse alpha → specular → check diffuse texture compression’ as PVRTC alpha compression is very destructive on the precision (smooth gradients on it is a thing that is potentially possible on Unity 3.5, but not 3.4.2 and earlier)

7

Switching to uncompressed texture did not changed a lot… for sure it look better, but the light problem was the same.

After many tweaks, i’ve altered the specular computation in LightingSimpleSpecular to limit it’s value.
float spec = pow (nh, _SpecPower);
became
float spec = min( 0.8, pow (nh, _SpecPower));

it’s not a perfect solution, but it’s an acceptable result for my goal.