[WIP] Ping

Modérateur : Administrateurs Suppléants

Avatar de l’utilisateur
Liven
Messages : 267
Inscription : 30 Nov 2017 01:48

Re: [WIP] Ping

Message par Liven » 24 Oct 2018 11:04

Je vais creuser la question.
Mais clairement ce sera pas par code, le codage des shader n'a absolument rien à voir avec le C# et la PoO, c'est une autre logique et n'ai clairement pas le courage de m'y pencher.
Par contre je crois voir quels outils utiliser sur shader graph par rapport à ce que tu dis, du coup je devrais pouvoir essayer.

djulio74
Messages : 432
Inscription : 19 Déc 2009 22:55
Contact :

Re: [WIP] Ping

Message par djulio74 » 24 Oct 2018 11:36

oui oui je sais bien que ça n'as rien a voir les shaders ;)
Mais vu ça fait un moment je n'y ai pas mis les mains, j'ai préféré montre le genre de arche a suivre en simple code.
d'ailleurs suis en train de m'amuser avec un shader pour essayer d'y appliquer ce que je te proposait. ;) ;-)

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
Liven
Messages : 267
Inscription : 30 Nov 2017 01:48

Re: [WIP] Ping

Message par Liven » 24 Oct 2018 11:47

Si tu tâtes un peu les shaders, saurai-tu me dire s'il y a des opérations particulièrement gourmandes qu'il vaut mieux éviter.
Pour l'instant j'y vais un peu à l'aveugle et n'ai pas vraiment trouvé de moyen de monitorer les perf des shaders.

djulio74
Messages : 432
Inscription : 19 Déc 2009 22:55
Contact :

Re: [WIP] Ping

Message par djulio74 » 24 Oct 2018 12:36

alors les shader je dirais que je suis doué, pour l'optimisation je sais pas trop.
le seul truc que je sais c'est faire attention a comment tu declare tes variable, par exemple entre float3, half3 et fixed3 : certes du plus précis au moins précis, mais aussi du coup du plus lourd a gérer au plus rapide.

Sachant que pour la plupart des opération un half suffit amplement, et fixed va bien niveau précision pour les valeurs entre 0 et 1.
j'ai trouvé ça dans la doc pour l'optimisation.

par exemple le shader de carrosserie que j'ai ecrit :

Code : Tout sélectionner

Shader "Perso/Carosserie" {


    Properties {

      _Color ("Main Color", Color) = (0.26,0.19,0.16,0.0) 
      _Color2 ("second Color", Color) = (0.26,0.19,0.16,0.0)  
      _Fallof ("second Color Fallof",  Range(3.0,40)) = 5
      _Intensity ("second Color Intensity",  Range(0.0,0.6)) = 0.1
      _Spec ("Specular Color", Color) = (1,1,1,0)  
      _SpecFallof ("Specular Fallof",  Range(50,15000)) = 500
      _SpecIntensity ("Specularr Intensity",  Range(0.0,10)) = 0.1
      _SkyIntensity ("Sky Intensity", Range(0.0, 1.0)) = 0.0
      _ReflInt ("reflection", Range(0.0,0.3)) = 0.1      
      _fresnel ("fresnel", Range(1,10.0)) = 5.0
      _fresnelRef ("fresnel reflection", Range(0,1)) = 0.5
      _Metalic (" Metalic effect", Range(0.0,1)) = 0.5
      _test ("test", Range(0,1)) = 1


      
    }
    SubShader {
      Tags { "RenderType" = "Opaque" }
      CGPROGRAM
      #pragma surface surf SimpleSpecular noambient
      #pragma target 3.0
      #pragma only_renderers d3d9 d3d11 opengl
      #pragma glsl
      
      
         samplerCUBE _Cube;    
     
         
         half4 _Color; 
         half4 _Color2;
         half4 _Spec;   
         half  _SkyIntensity; 
         half  _Fallof;
         half  _Intensity;
         half  _SpecFallof;
         half  _SpecIntensity;
         half  _ReflInt; 
         half  _fresnelRef;
         half  _fresnel;
         half  _Metalic;
         half _test;



   

      half4 LightingSimpleSpecular (SurfaceOutput s, half3 lightDir, half3 viewDir, half atten) {
      
      half blur = 7;
      
      half3 VecRef = reflect( viewDir , s.Normal); 													// vecteur reflection 
                 
            half3 VecHdri = normalize(-reflect(viewDir,s.Normal) + s.Normal) ;
            half x = VecHdri.x;   
      		half y = VecHdri.y;  
      		half z = VecHdri.z;
      		
half3 dir1 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.1);
half3 dir2 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.1);
half3 dir3 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.1);       
half3 dir4 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.1); 
half3 dir5 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.1);
half3 dir6 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.1);

half3 dir11 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.2);
half3 dir12 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.2);
half3 dir13 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.2);       
half3 dir14 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.2); 
half3 dir15 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.2);
half3 dir16 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.2);

half3 dir21 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.3);
half3 dir22 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.3);
half3 dir23 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.3);       
half3 dir24 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.3); 
half3 dir25 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.3);
half3 dir26 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.3);

half3 dir31 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.4);
half3 dir32 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.4);
half3 dir33 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.4);       
half3 dir34 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.4); 
half3 dir35 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.4);
half3 dir36 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.4);

half3 dir41 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.5);
half3 dir42 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.5);
half3 dir43 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.5);       
half3 dir44 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.5); 
half3 dir45 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.5);
half3 dir46 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.5);

half3 dir51 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.6);
half3 dir52 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.6);
half3 dir53 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.6);       
half3 dir54 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.6); 
half3 dir55 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.6);
half3 dir56 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.6);

half3 dir61 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.7);
half3 dir62 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.7);
half3 dir63 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.7);       
half3 dir64 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.7); 
half3 dir65 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.7);
half3 dir66 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.7);

half3 dir71 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.8);
half3 dir72 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.8);
half3 dir73 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.8);       
half3 dir74 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.8); 
half3 dir75 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.8);
half3 dir76 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.8);

half3 dir81 =  normalize(VecHdri + normalize(half3( -y,x,0))*0.9);
half3 dir82 =  normalize(VecHdri + normalize(half3( 0,-z,y))*0.9);
half3 dir83 =  normalize(VecHdri + normalize(half3( -z,0,x))*0.9);       
half3 dir84 =  normalize(VecHdri - normalize(half3( -y,x,0))*0.9); 
half3 dir85 =  normalize(VecHdri - normalize(half3( 0,-z,y))*0.9);
half3 dir86 =  normalize(VecHdri - normalize(half3( -z,0,x))*0.9);



half3 RefColor1 = texCUBElod (_Cube, float4(dir1,blur)) * dot(VecHdri,dir1) ;
half3 RefColor2 = texCUBElod (_Cube, float4(dir2,blur)) * dot(VecHdri,dir2) ;
half3 RefColor3 = texCUBElod (_Cube, float4(dir3,blur)) * dot(VecHdri,dir3) ;
half3 RefColor4 = texCUBElod (_Cube, float4(dir4,blur)) * dot(VecHdri,dir4) ;
half3 RefColor5 = texCUBElod (_Cube, float4(dir5,blur)) * dot(VecHdri,dir5) ;	
half3 RefColor6 = texCUBElod (_Cube, float4(dir6,blur)) * dot(VecHdri,dir6) ;

half3 RefColor11 = texCUBElod (_Cube, float4(dir11,blur)) * dot(VecHdri,dir11) ;
half3 RefColor12 = texCUBElod (_Cube, float4(dir12,blur)) * dot(VecHdri,dir12) ;
half3 RefColor13 = texCUBElod (_Cube, float4(dir13,blur)) * dot(VecHdri,dir13) ;
half3 RefColor14 = texCUBElod (_Cube, float4(dir14,blur)) * dot(VecHdri,dir14) ;
half3 RefColor15 = texCUBElod (_Cube, float4(dir15,blur)) * dot(VecHdri,dir15) ;	
half3 RefColor16 = texCUBElod (_Cube, float4(dir16,blur)) * dot(VecHdri,dir16) ;

half3 RefColor21 = texCUBElod (_Cube, float4(dir21,blur)) * dot(VecHdri,dir21) ;
half3 RefColor22 = texCUBElod (_Cube, float4(dir22,blur)) * dot(VecHdri,dir22) ;
half3 RefColor23 = texCUBElod (_Cube, float4(dir23,blur)) * dot(VecHdri,dir23) ;
half3 RefColor24 = texCUBElod (_Cube, float4(dir24,blur)) * dot(VecHdri,dir24) ;
half3 RefColor25 = texCUBElod (_Cube, float4(dir25,blur)) * dot(VecHdri,dir25) ;	
half3 RefColor26 = texCUBElod (_Cube, float4(dir26,blur)) * dot(VecHdri,dir26) ;

half3 RefColor31 = texCUBElod (_Cube, float4(dir31,blur)) * dot(VecHdri,dir31) ;
half3 RefColor32 = texCUBElod (_Cube, float4(dir32,blur)) * dot(VecHdri,dir32) ;
half3 RefColor33 = texCUBElod (_Cube, float4(dir33,blur)) * dot(VecHdri,dir33) ;
half3 RefColor34 = texCUBElod (_Cube, float4(dir34,blur)) * dot(VecHdri,dir34) ;
half3 RefColor35 = texCUBElod (_Cube, float4(dir35,blur)) * dot(VecHdri,dir35) ;	
half3 RefColor36 = texCUBElod (_Cube, float4(dir36,blur)) * dot(VecHdri,dir36) ;

half3 RefColor41 = texCUBElod (_Cube, float4(dir41,blur)) * dot(VecHdri,dir41) ;
half3 RefColor42 = texCUBElod (_Cube, float4(dir42,blur)) * dot(VecHdri,dir42) ;
half3 RefColor43 = texCUBElod (_Cube, float4(dir43,blur)) * dot(VecHdri,dir43) ;
half3 RefColor44 = texCUBElod (_Cube, float4(dir44,blur)) * dot(VecHdri,dir44) ;
half3 RefColor45 = texCUBElod (_Cube, float4(dir45,blur)) * dot(VecHdri,dir45) ;	
half3 RefColor46 = texCUBElod (_Cube, float4(dir46,blur)) * dot(VecHdri,dir46) ;

half3 RefColor51 = texCUBElod (_Cube, float4(dir51,blur)) * dot(VecHdri,dir51) ;
half3 RefColor52 = texCUBElod (_Cube, float4(dir52,blur)) * dot(VecHdri,dir52) ;
half3 RefColor53 = texCUBElod (_Cube, float4(dir53,blur)) * dot(VecHdri,dir53) ;
half3 RefColor54 = texCUBElod (_Cube, float4(dir54,blur)) * dot(VecHdri,dir54) ;
half3 RefColor55 = texCUBElod (_Cube, float4(dir55,blur)) * dot(VecHdri,dir55) ;	
half3 RefColor56 = texCUBElod (_Cube, float4(dir56,blur)) * dot(VecHdri,dir56) ;

half3 RefColor61 = texCUBElod (_Cube, float4(dir61,blur)) * dot(VecHdri,dir61) ;
half3 RefColor62 = texCUBElod (_Cube, float4(dir62,blur)) * dot(VecHdri,dir62) ;
half3 RefColor63 = texCUBElod (_Cube, float4(dir63,blur)) * dot(VecHdri,dir63) ;
half3 RefColor64 = texCUBElod (_Cube, float4(dir64,blur)) * dot(VecHdri,dir64) ;
half3 RefColor65 = texCUBElod (_Cube, float4(dir65,blur)) * dot(VecHdri,dir65) ;	
half3 RefColor66 = texCUBElod (_Cube, float4(dir66,blur)) * dot(VecHdri,dir66) ;

half3 RefColor71 = texCUBElod (_Cube, float4(dir71,blur)) * dot(VecHdri,dir71) ;
half3 RefColor72 = texCUBElod (_Cube, float4(dir72,blur)) * dot(VecHdri,dir72) ;
half3 RefColor73 = texCUBElod (_Cube, float4(dir73,blur)) * dot(VecHdri,dir73) ;
half3 RefColor74 = texCUBElod (_Cube, float4(dir74,blur)) * dot(VecHdri,dir74) ;
half3 RefColor75 = texCUBElod (_Cube, float4(dir75,blur)) * dot(VecHdri,dir75) ;	
half3 RefColor76 = texCUBElod (_Cube, float4(dir76,blur)) * dot(VecHdri,dir76) ;

half3 RefColor81 = texCUBElod (_Cube, float4(dir81,blur)) * dot(VecHdri,dir81) ;
half3 RefColor82 = texCUBElod (_Cube, float4(dir82,blur)) * dot(VecHdri,dir82) ;
half3 RefColor83 = texCUBElod (_Cube, float4(dir83,blur)) * dot(VecHdri,dir83) ;
half3 RefColor84 = texCUBElod (_Cube, float4(dir84,blur)) * dot(VecHdri,dir84) ;
half3 RefColor85 = texCUBElod (_Cube, float4(dir85,blur)) * dot(VecHdri,dir85) ;	
half3 RefColor86 = texCUBElod (_Cube, float4(dir86,blur)) * dot(VecHdri,dir86) ;

half3 Ref = (RefColor1 + RefColor2 + RefColor3 + RefColor4 + RefColor5 + RefColor6  )/ 6  ;
half3 Ref1 = (RefColor11 + RefColor12 + RefColor13 + RefColor14 + RefColor15 + RefColor16  )/ 6  ;
half3 Ref2 = (RefColor21 + RefColor22 + RefColor23 + RefColor24 + RefColor25 + RefColor26  )/ 6  ;
half3 Ref3 = (RefColor31 + RefColor32 + RefColor33 + RefColor34 + RefColor35 + RefColor36  )/ 6  ;
half3 Ref4 = (RefColor41 + RefColor42 + RefColor43 + RefColor44 + RefColor45 + RefColor46  )/ 6  ;
half3 Ref5 = (RefColor51 + RefColor52 + RefColor53 + RefColor54 + RefColor55 + RefColor56  )/ 6  ;
half3 Ref6 = (RefColor61 + RefColor62 + RefColor63 + RefColor64 + RefColor65 + RefColor66  )/ 6  ;
half3 Ref7 = (RefColor71 + RefColor72 + RefColor73 + RefColor74 + RefColor75 + RefColor76  )/ 6  ;
half3 Ref8 = (RefColor81 + RefColor82 + RefColor83 + RefColor84 + RefColor85 + RefColor86  )/ 6  ;



half3 Sky = (Ref + Ref1 + Ref2 + Ref3 + Ref4 + Ref5 + Ref6 + Ref7 + Ref8 )/9 ;

      	half fresnel = pow(1 - dot (s.Normal, viewDir ), _fresnel )*_fresnelRef ;  						// fresnel value
      
      	half MetalicEffect = pow(1 - dot (s.Normal, viewDir ), _fresnel ) * _Metalic ;					// Metalic Effect
      	
        half3 h = normalize (lightDir + viewDir);
        
        half diff = max (0, dot (s.Normal, lightDir)); 
                 
        half nh = max (0, dot (s.Normal, h));  
                
        half Col2 = pow (nh, _Fallof)*_Intensity; 														// falloff Couleur secondaire
        
        half Spec = pow (nh, _SpecFallof)*_SpecIntensity;     											// falloff Speculaire         
           
        half3 LightingColor = (s.Albedo * _LightColor0.rgb*_Color.rgb * diff * (1 - MetalicEffect)) / (1+_SkyIntensity) ; 	// Couleur Principal
        
        half3 LightingColor1 =_LightColor0.rgb*_Color2.rgb * Col2* (1 - MetalicEffect);					// couleur Secondaire
        
        
		half3 blurhdri = texCUBElod (_Cube, float4(-VecRef,4 ));
        
		half3 RefColor = texCUBE (_Cube, -VecRef).rgb * (_ReflInt + fresnel) * texCUBE (_Cube, -VecRef) * (max(1-_test,blurhdri)/(1-_test))  ;			//reflection ( direct + fresnel)
	
               
        half3 Specul = _Spec.rgb * Spec *_LightColor0.rgb;
        

        half3 SkyColor = Sky * _Color *_SkyIntensity* (1 - MetalicEffect) * max(0.45,Sky)/0.45;
        
        
          half4 c;
          	c.rgb = ((LightingColor.rgb  +LightingColor1.rgb)  + Specul)* (atten * 2) + SkyColor.rgb + RefColor.rgb ;
			c.a = s.Alpha;
          	return c;
      } 

      struct Input {
          float2 uv_MainTex;           
      	
      };
      	sampler2D _MainTex;    


      void surf (Input IN, inout SurfaceOutput o  ) {

 
         o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;

      }
      ENDCG
    }
    Fallback "Diffuse"
  }
malgré la longueur et le nombre d'opé il est pas trop gourmand en ressource. le plus lourd étant toute mes itération de calcul sur la cubeMap

après je pense que c'est un peu comme en C# avec tout ce qui découle de Mathf.

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

djulio74
Messages : 432
Inscription : 19 Déc 2009 22:55
Contact :

Re: [WIP] Ping

Message par djulio74 » 24 Oct 2018 16:55

EDIT
J'ai essayé d'améliorer tout ça , j'ai fait un petite vidéo, si ça t’intéresse je te passe le shader, toujours qu'un seul plan, une seule texture, un seul shader.. ;)

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
Liven
Messages : 267
Inscription : 30 Nov 2017 01:48

Re: [WIP] Ping

Message par Liven » 26 Oct 2018 05:22

djulio74 a écrit :
24 Oct 2018 16:55
EDIT
J'ai essayé d'améliorer tout ça , j'ai fait un petite vidéo, si ça t’intéresse je te passe le shader, toujours qu'un seul plan, une seule texture, un seul shader.. ;)
Et ben j'étais passé à coté de ton édit.

Ton résultat est très intéressant, effectivement si je peux arriver à gérer le fond avec quelque chose du genre ce serait niquel.

Par contre comme je disais, le HLSL pour moi c'est vraiment du chinois et je n'ai ni l'envie ni le courage de vraiment me plonger dedans. Ma démarche n'est pas forcément d'obtenir le shader de fond parfait, mais d'utiliser la création de ce fond (et d'autres choses) pour apprendre à me servir du shader graph.
Du coup plutôt que le shader et son code, je suis d'avantage intéressé par la logique qui conduit à de tels résultats. Par exemple je vois bien comment clamp les noises pour faire du pur "noir et blanc" mais j'ai encore du mal à voir comment contrôler le floue intermédiaire (qui semble te servir pour le focus et la netteté)

djulio74
Messages : 432
Inscription : 19 Déc 2009 22:55
Contact :

Re: [WIP] Ping

Message par djulio74 » 26 Oct 2018 09:17

Oui c'est sur que le codage pur de shader peut être assez déroutant et fastidieux au debut, je suis passé par des test et de test et des test... lol. Donc bon je vais essayer d'expliquer la logique de mon shader en espérant que tu puisse le transposer au ShaderGraph. ;-)

Alors pour le floue, c'est des mathématiques pure, et pour ce genre de chose, je me sert d'un traceur de courbe ( sur le net) pour rechercher et mettre au point une formule pour un résultat voulu. Mais ça reste des fonctions simples : Y = f(x).
=> X est la valeur de base de la texture au coordonnées UV du pixel qu'on calcul (compris de 0.0f a 1.0f , le grayscale en somme)
=> Y la valeur que l'on veux obtenir/affiché pour ce pixel, idem de 0 a 1.

J'ai donc ajouté une "raideur" à X pour jouer sur la verticalité de la fonction tout en gardant un passage à (0.5,0.5). Quelque soit la modification de x ( f(x) ) il faut toujours que Y(0.5) = 0.5.
ce qui donne : Y = x*Raideur - (Raideur-1.0)/2.0. avec raideur = Range( 1.0, 100.0).
Pour éviter les valeurs négative et supp. à 1.0, on clamp :
Y = clamp( { x*Raideur - (Raideur-1.0)/2.0} , 0.0 , 1.0)
Image

Maintenant pour la proportion de noir et blanc, il faut décaler cette courbe horizontalement.
Je passe les essai et donne le résultat final :
Y = clamp( { x*Raideur - (Raideur-1.0)/2.0} , 0.0 , 1.0) - Ratio* (Raideur-1.0)/2.0 / avec ratio = Range ( -1.0 , 1.0).
pour raideur = 4, ratio = 0 :
Image

Mais du coup on perd en nuance entre 0 et 1 pour Y vu que X a été multiplié puis clampé. Je passe donc par un cosinus. Mais cos(x) est sinusoïdal de -1 a 1 avec un période de 2 Pi. Idem je te passe les recherche mais on tombe sur ;
cos(x*pi)/2.0 + 0.5
Image

ici X étant la valeur du pixel déjà modifiée :
( Y = clamp( { X *Raideur - (Raideur-1.0)/2.0} , 0.0 , 1.0) - Ratio* (Raideur-1.0)/2.0)
On a juste a remplacer le x du cosinus par Y :

Y1 = clamp( { x*Raideur - (Raideur-1.0)/2.0} , 0.0 , 1.0) - Ratio* (Raideur-1.0)/2.0
Y = cos(Y1*pi)/2.0 + 0.5.

Exemple avec Raideur = 2.
Image
Bon OK, on arrive à modifier la netteté(raideur) et le ratio du perlin.
Pour ajouter les couches pour la profondeur :
j'ai utilisé la donnée viewDir que tu dois certainement avoir aussi dans le shaderGraph. en fait ça défini le vecteur normalisé partant de la caméra, jusqu'au pixel qu'on calcul.

Donc pour chaque n couche supplémentaire qu'on veut faire, au lieu de prendre la valeur du pixel souhaité, on va prendre le pixel avec un UV différent, décalé de n*profondeur*viewDir.xz. donc au centre de l'écran, aucun décalage, et plus on va sur les bords, plus le décalage est grand, et plus on va en profondeur également.
C'est la partie la moins facile à expliquer. :hehe: ::d
pour schématiser pour chaque couche n

- UV(n) = coordonnées UV(xy) du pixel a claculer + viewDir (xz)*n*profondeur.
- X (n) = valeur grayscale du perlin du pixel au coordonnées UV(n) . Range(0, 1)
- Y1(n) = valeur grayscale limité avec raideur et ratio du pixel X (n)
- Y(n) = niveau de gris à afficher avec le cos ( lissage) pour le pixel X (n) Range (0,1)
->> la valeur final à afficher étant la somme de toute les couche Y(n).

le problème c'est que toute les couches se superposent, pour remédier il faut que chaque couche soit noir là ou la précédente est blanche ( la blanc étant une partie pleine, censée masquer la couche d'en dessous). on multipli donc chaque couche Y1(n) par (1-Y(n-1))
ce qui donne :
Image
les couches sont identiques, superposée avec une vision de profondeur.
pour donner l’illusion que chaque couche est différente, il suffit d'ajouter un vector2 différent à chaque UV(n)
et pour le focus, il faut diminuer la raideur de chaque couche, en divisant par focus*(n+1), de plus en plus floue plus on s'éloigne

au final pour chaque couche n :

- Raideur (n) = raideur/(focus*(n+1));
- UV(n) = coordonnées UV(xy) du pixel a claculer + viewDir (xz)*n*profondeur + vector2(n) prédéfini.
- X (n) = valeur grayscale du perlin du pixel au coordonnées UV(n)
- Y1(n) = valeur grayscale limité (avec raideur(n) et ratio ) * (1.0-Y(n-1))
- Y(n) = niveau de gris à afficher avec le cos ( lissage) pour le pixel X (n)
->> la valeur final à afficher étant la somme de toute les couche Y(n).

Voila pour toute l'explication, j’espère avoir été assez clair et au cas ou, demande ;-)

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
Liven
Messages : 267
Inscription : 30 Nov 2017 01:48

Re: [WIP] Ping

Message par Liven » 26 Oct 2018 10:33

Oulala, il va me falloir du temps pour digérer tout ça.

Je crois voir la démarche générale, je vais garder ce message sous le coude car je vais avoir besoin de le lire le relire... et faire un max de tests.
Cependant comme shader graph n'est pas encore tout à fait mûr (il y a notamment un bug qui fait que je suis quasi obligé de travailler à l'aveugle sur mon projet en cours), je pense que je ne vais pas me lancer dans des calculs aussi complet pour l'instant.

Je vais rester sur ma première itération pour l'instant et voir ce que je peux faire sur les autres éléments du jeu, puis je repencherais sur le sujet quand je ferais une seconde pass sur les shaders (en espérant que le shader graph soit plus stable). Ouai, je vais faire ça car je sent que mon cerveau commence à fondre.

En tout cas merci pour le temps que tu as consacré à me répondre.

djulio74
Messages : 432
Inscription : 19 Déc 2009 22:55
Contact :

Re: [WIP] Ping

Message par djulio74 » 26 Oct 2018 11:56

Je viens de jeter un œil sur le fonctionnement du shader graph, et c'est bien ce qu'il me semblait, une histoire de nœud.
Mais au vu des quelques screen que j'ai aperçu, c'est gérable aussi.
Ça me rappel quand j'avais essayé Quest3D, ou il n'y avait aucun script, tout était sous forme de node comme ici.

une simple question, est-il possible de créer un bloc personnalisé? définir combines d'entrée/sortie et leur type ou faut il utiliser un bloc pour chaque opération de base ( add, multipli..etc)?

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
boubouk50
ModoGenereux
ModoGenereux
Messages : 4651
Inscription : 28 Avr 2014 11:57
Localisation : Toulouse

Re: [WIP] Ping

Message par boubouk50 » 26 Oct 2018 11:56

Tu as toujours la possibilité de faire du parallax avec une superposition de textures.
https://www.youtube.com/watch?v=OS3ViXHtrUU
"Ce n'est pas en améliorant la bougie, que l'on a inventé l'ampoule, c'est en marchant longtemps."
Nétiquette du forum
Savoir faire une recherche
Apprendre la programmation

Répondre

Revenir vers « Vos créations, jeux, démos... »