[RESOLU] Shader: NormalMap et Android

[SamothSamoth]

Bein alors !!! t'es en "nolighting"....

Essaye en juste en #pragma lambert. Je sais plus exactement la definition mais essayes avec ca. Et Fallback en "mobile".

Y'a plus que ca

[F@B]

le stantard doit macher sur mobile et en effet si t'es en nolightning pas de normal!

et si tu applique la normal sur le diffuse pour le débug?

[boubouk50]

Je pense pas que le noLighting soit mis en cause. Les normales doivent réagir avec une cubeMap pas la lumière. Il me semble qu'en Lambert ça ne marchait pas non plus.
@F@b: Pourquoi pas de light pas de normale?

[F@B]

si je ne dis pas de connerie le bump n'est qu'une modification de l'éclairage par pixel selon la normalmap.

https://en.wikibooks.org/wiki/Cg_Progra ... y_Surfaces

[boubouk50]

La normalMap est une déformation par texture de la normale au pixel. Les normales ne sont pas seulement utiles pour le calcul de diffuse ou de spéculaire (même si c'est pour 90% des cas peut-être), donc calcul lié à la lumière, elles sont aussi utiles pour le calcul de réflexion, de fresnel, de heightmap, etc, enfin tout ce qui touche à la surface. Ici, je souhaite créer un shader d'eau simple avec une normalMap unique qui se superpose à elle-même avec des offsets différents en fonction du temps. Ma normalMap est utilisée pour la réflexion et le fresnel. Je pourrai également l'utiliser pour la diffuse et le spéculaire, mais tout est static et lightmappé dans ma scène. Donc pas de lumière dynamique.

Je suis entrain de bidouiller tout ça en CG, il ne me manque plus que la transparence à gérer, et là est mon nouveau problème d'ailleurs...

- EDIT - pour info: c'est même un problème dans les jeux, si tu as des objets qui sont "réalistes et beaux" grâce à la normalMap, que se passe-t-il lorsque cet objet passe dans l'ombre? Il devient "plat et moche". Si par contre tu as utilisé la normalMap dans l'ambient pass, alors elle servira à rajouter ce détail qui rend l'objet plus vivant, dynamique, détaillé.

[boubouk50]

J'ai un problème de tri. Le mesh avec le shader est par moment devant ou derrière les autres objets ce qui bien évidemment n'est pas voulu. Le code:

Code : Tout sélectionner

Tags {"Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" "LightMode" = "Always"}
LOD 200
Cull Back
ZWrite Off // don't write to depth buffer 
Blend SrcAlpha OneMinusSrcAlpha
...

le résultat (la boule bleue est derrière la boule d'eau qui sont au dessus d'un plan gris):

A noter que la sphère d'eau ne se dessine pas au dessus d'une skybox d'environnement, comme si elle était toujours dessinée avant.

[boubouk50]

Un autre visuel pour vous rendre mieux compte du problème. On dirait que le fresnel est calculé en fonction du mauvais Space.

Les sphères bleues sont derrières le plan (toujours ce pb de tri) et la réflexion est boosté (surement du au fait que les normales soient inversées donc le calcul par en dehors des limites [0, 1].
Les normalMaps maintenant sont correctement appliquées (en terme d'UV et de mapping), mais le résultat issu des calculs de réflexion est désastreux.

Code : Tout sélectionner

Shader "ToutouYoutou/Fresnel" {
	Properties {
		_DiffuseColor ("Diffuse Color", Color) = (0, 0, 0, 0.5)
		_BumpMap ("Normal Map", 2D) = "bump" {}
		_Cube ("Reflection Cubemap", Cube) = "" {}
		_Fresnel ("Fresnel Intensity", Float) = 1.0
	}
	SubShader {
		Pass {
			Tags {"Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" "LightMode" = "Always"}
			LOD 200
			
			Cull Back
        	ZWrite Off // don't write to depth buffer 
        	Blend SrcAlpha OneMinusSrcAlpha 
			
			CGPROGRAM
			// Physically based Standard lighting model, and enable shadows on all light types
			#pragma vertex vert
			#pragma fragment frag
			#include "UnityCG.cginc"

			uniform sampler2D _BumpMap;
			uniform float4 _BumpMap_ST;
			uniform samplerCUBE _Cube;
			uniform fixed4 _DiffuseColor;
			uniform float _Fresnel;

			struct vertexInput {
				float4 vertex : POSITION;
				float4 texcoord : TEXCOORD0;
				float3 normal : NORMAL;
				float4 tangent : TANGENT;
			};
			
			struct vertexOutput {
				float4 pos : SV_POSITION;
				float4 posWorld : TEXCOORD0;
				float4 tex : TEXCOORD1;
				float3 tangentWorld : TEXCOORD2;  
				float3 normalWorld : TEXCOORD3;
				float3 binormalWorld : TEXCOORD4;
			};
	         
			vertexOutput vert(vertexInput input) 
			{
				vertexOutput output;

				float4x4 modelMatrix = _Object2World;
				float4x4 modelMatrixInverse = _World2Object; 

				output.tangentWorld = normalize (mul (modelMatrix, float4 (input.tangent.xyz, 0.0)).xyz);
				output.normalWorld = normalize (mul (float4(input.normal, 0.0), modelMatrixInverse).xyz);
				output.binormalWorld = normalize (cross (output.normalWorld, output.tangentWorld) * input.tangent.w); 

				output.posWorld = mul (modelMatrix, input.vertex);
				output.tex = input.texcoord;
				output.pos = mul (UNITY_MATRIX_MVP, input.vertex);
				return output;
			}

			float4 frag(vertexOutput input) : COLOR
			{
				float4 encodedNormal1 = tex2D (_BumpMap, _BumpMap_ST.xy * input.tex.xy + float2 (_BumpMap_ST.z, 0.0));
				float3 localCoords1 = float3 (2.0 * encodedNormal1.a - 1.0, 2.0 * encodedNormal1.g - 1.0, 0.0);
				localCoords1.z = sqrt (1.0 - dot (localCoords1, localCoords1));
				float4 encodedNormal2 = tex2D (_BumpMap, _BumpMap_ST.xy * input.tex.xy + float2 (0.0, _BumpMap_ST.w));
				float3 localCoords2 = float3 (2.0 * encodedNormal2.a - 1.0, 2.0 * encodedNormal2.g - 1.0, 0.0);
				localCoords2.z = sqrt (1.0 - dot (localCoords2, localCoords2));

				float3x3 local2WorldTranspose = float3x3 (input.tangentWorld, input.binormalWorld, input.normalWorld);
				
				float3 normalDirection = normalize (normalize (mul (localCoords1, local2WorldTranspose)) + normalize (mul (localCoords2, local2WorldTranspose)));
				float3 viewDirection = normalize (_WorldSpaceCameraPos - input.posWorld.xyz);

				float3 reflectDir = reflect (viewDirection, normalDirection);
				fixed3 reflcol = texCUBE (_Cube, reflectDir);
				fixed rim = (_Fresnel - dot (viewDirection, normalDirection) * 0.9);

				float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _DiffuseColor.rgb;
				float3 diffuseReflection = _DiffuseColor.rgb;

				return float4(ambientLighting + diffuseReflection + reflcol * rim, _DiffuseColor.a * rim);
			}
			ENDCG
		}
	}
	Fallback "Transparent/Diffuse"
}

Pour les courageux

Voilà ce que ça donne lorsque je retourne float4(normalDirection, 1.0); (Android a gauche et Standalone Win a droite)

[boboss]

salut boubouk50

ça n'a pas l'air simple ton problème, et je suis pas du tout a l'aise avec les shaders pour android

une idée comme ça quand même au cas où

Dans ton vertex shader tu fais ça :
output.tex = input.texcoord;

cependant dans beaucoup d'exemple on voit ça :

output.tex= TRANSFORM_TEX(input.texcoord,_MainTex);

Boboss

[boubouk50]

TRANSFORM_TEX() est une macro propre à Unity afin d'appliquer le scale et l'offset d'UV dans l'inspector d'Unity. Dans ce script, je joue avec les offsets dans le fragment shader pour animer les normalMaps donc il me faut les UVs de départ non transformés par Unity. Voilà pourquoi je récupère les UVs sans transformations et pas avec TRANSFORM_TEX(). Ce n'est pas la raison de mon problème. Les UVs ne sont pas mis en cause.
Je pense que cela se joue plutôt au niveau des matrices de transformation comme si sous Android les matrices reçues ou envoyées n'étaient pas les bonnes.

[SamothSamoth]

Ca peut être ca. Du left hand ou du right hand !