Flat clouds in P3D

[dave2013 1,130]

17 hours ago, Rogen said:

The cloud textures themselves are from Rex Texure Direct with Soft Clouds.

I'm a bit confused.  First you said that the clouds in your screenshots were from a freeware set linked to in the posts from kiwi_biplane.

Then in your next post you say they are from REX Texture Direct Soft Clouds.

So, which is it?

Thanks.

Dave

[Rogen 1,087]

7 hours ago, dave2013 said:

I'm a bit confused.  First you said that the clouds in your screenshots were from a freeware set linked to in the posts from kiwi_biplane.

Then in your next post you say they are from REX Texture Direct Soft Clouds.

So, which is it?

Thanks.

Dave

Hi Dave,

Yes, I can see confusion may arise.

kiwi_biplane's links contain both cloud textures and the key for dynamic lighting, being shader files.

The actual look, i.e. the dynamic lighting, is created by a custom shader.

The cloud textures are whatever you want to use, kiwi_biplane's cloud textures just happen to be custom made to suit the dynamic cloud shader.

So to get dynamically lit clouds you'd go for either A or B.

A:

• use the custom Cloud.fx shader.
• use whatever cloud textures you'd prefer except for kiwi_biplane's cloud shader optimised textures.
• PRO: Can swap back to the original Cloud.fx without issue.

B:

• use the custom Cloud.fx shader.
• use kiwi_biplane's cloud shader optimised textures.
• CON: Can not swap back to the original Cloud.fx

The cloud textures can be whatever you think looks good and works for yourself, mine happen to be REX based which means I can swap back to my standard Cloud.fx shader without issue.

If you want to use kiwi_biplane's cloud textures you'd also need to always use the custom Cloud.fx shader, otherwise the cloud colours are somewhat messed up.

Because the links contain many files and would essentually overwrite your own install, I've included the custom Cloud.fx shader in a spoiler.

• Get yourself Notepad++ (it's a great and free text editor)
• Navigate in Windows Explorer to P3D's shader files e.g. ~\Lockheed Martin\Prepar3D v4\ShadersHLSL
• Make sure Windows Explorer has View | File Name Extensions enabled.
• Make 2 x copies of the Cloud.fx file

Rename the two copies as per examples below.

• Cloud.fx.DynamicLighting
• Cloud.fx.Original

Open Cloud.fx.DynamicLighting in Notepad++

• Copy all the spolier text and use it to replace all the original text in Cloud.fx.DynamicLighting and save Cloud.fx.DynamicLighting
• Open Cloud.fx in Notepad++
• Copy all the Cloud.fx.DynamicLighting text and paste into Cloud.fx replacing all the original text then save Cloud.fx
• Navigate to C:\Users\Your.Account.Name\AppData\Local\Lockheed Martin\Prepar3D v4\Shaders
• Delete all the files within this shader cache (this folder is full of *.cso cached compiled shaders that are created dynamically when P3D runs).

That's it, when P3D is next run the compiled shaders will regenerate and your current cloud textures will have dynamic lighting.

To revert back to the original shader - copy the text from Cloud.fx.Original into Cloud.fx replacing all the original text and save Cloud.fx, then clear the shader cache again.

Cheers

PS: I just realised kiwi_biplane's older release cloud textures are not the optimised ones for the dynamic lighting, so feel free to trial them out if desired.

Cloud.fx with dynamic lighting for latest v4.5 P3D version.

Spoiler

//---------------------------------------------------------------------------
// Prepar3d - Shader Effect Files
// Copyright (c) 2014, Lockheed Martin Corporation
//---------------------------------------------------------------------------

#include "ShaderMacros.h"
#include "ConstantBuffers.fxh"
#include <FuncLibrary.fxh>
#include <IRSim.fxh>
#include <InstanceIndexing.fxh>
#define MAX_COLOR_LEVELS 5

shared Texture2D txBase : REGISTER(t, 0);
shared Texture2D txSceneDepth : REGISTER(t,SCENE_DEPTH_TEXTURE_REGISTER);

    static float FA1 = frac((25+cb_Altitude)/1000) ; static float FA0 = frac((25+cb_Altitude)/100) ; // ѕеременные дл¤ тестовых настроек.
    static float fT0 = abs( frac(  (  cb_mFog[0].cb_mFogTop + cb_Altitude  ) /1000) ) ; static float fB0 = abs( frac(  (  cb_mFog[0].cb_mFogBase + cb_Altitude  ) /1000) ) ; //
    static float fT1 = abs( frac(  (  cb_mFog[1].cb_mFogTop + cb_Altitude  ) /1000) ) ; static float fB1 = abs( frac(  (  cb_mFog[1].cb_mFogBase + cb_Altitude  ) /1000) ) ; //
    static float fT2 = abs( frac(  (  cb_mFog[2].cb_mFogTop + cb_Altitude  ) /1000) ) ; static float fB2 = abs( frac(  (  cb_mFog[2].cb_mFogBase + cb_Altitude  ) /1000) ) ; //

//    static float FFz =  abs(cb_mViewFacingVector.z) ; static float FF1z =  1-abs(cb_mViewFacingVector.z) ; //
//    static float FFx =  1-abs(cb_mViewFacingVector.x) ; static float FF1x =  1-abs(cb_mViewFacingVector.x) ; //

// Ќј—“–ќ… » ¬≈–Ў»ЌЌќ√ќ Ў≈…ƒ≈–ј (VS)
//****************************************************************************************************************************************

//√≈ќћ≈“–»„≈— »≈ Ќј—“–ќ… »
// –азмер текстур облаков 0.1 ~ 1
 static const float SetVS1 = 0.65 ; // 0.75
// ѕространственный размер облаков по ос¤м X, Y, и Z.
 static const float SetVS2x = 1.3 ;  static const float SetVS2y = 0.85 ;  static const float SetVS2z = 1.3 ; //

// ѕоддвиг облаков к горизонту на границе видимости.
 static const float SetVS3 = 1 ; // ¬ключение - выключение твика. 1 - включено. 0 - выключено
//            ¬ысота поддвига. m   //  ƒистанци¤ поддвига ~ = дальности видимости*0.9. m   //   рутизна опускани¤.
 static const float SetVS3H = 3000 ;    static const float SetVS3D = 170000 ;                    static const float SetVS3S = 0.00008 ; //

//====================================================================================================================================================

// Ќј—“–ќ… » Ѕј«ќ¬ќ√ќ ¬≈–“» јЋ№Ќќ√ќ √–јƒ»≈Ќ“ј ќЅЋј ќ¬ (VGB)
//===================================================================================================================================================
// ћинимальна¤ крутизна градиента ( дл¤ облаков максимальной толщины )
 static const float SetVS10 = 1.5 ; //
// ћаксимальна¤ крутизна градиента ( дл¤ облаков минимальной толщины )
 static const float SetVS11 = 35 ; //
//  рутизна вертикального градиента облаков
 static const float SetVS12 = 8 ; //
// ќбща¤ коррекци¤ смещени¤ вертикального градиента облаков
 static const float SetVS13 = -0.0 ; //
// ќбща¤ коррекци¤ крутизны вертикального градиента облаков
 static const float SetVS14 = 1.0 ; //
// ƒополнительное усиление детализации базового вертикального градиента облаков
 static const float SetVS15 = 0.22 ; //
// я– ќ—“Ќџ≈ Ќј—“–ќ… » ÷¬≈“ј Ѕј«ќ¬ќ√ќ ¬≈–“» јЋ№Ќќ√ќ √–јƒ»≈Ќ“ј ќЅЋј ќ¬
// Ќачальный минимальный коэффициент ¤ркости подошвы на малых высотах расположени¤ облака ( ~< 1.5 km )
 static const float SetVS20 = 0.55 ; //
// Ќачальный минимальный коэффициент ¤ркости подошвы на больших высотах расположени¤ облака ( ~> 5.5 km )
 static const float SetVS21 = 0.77 ; //
// Ќачальный максимальный коэффициент ¤ркости вершин
 static const float SetVS22 = 1.45  ; //
// Ќачальный максимальный коэффициент ¤ркости вершин при низком положении —олнца на солнечной оппозиции
 static const float SetVS22o = 1.80  ; //
// ”ровень минимальной базовой детализации на основе fIntensity
 static const float SetVS23 = 0.25 ; //
// я– ќ—“Ќџ≈ Ќј—“–ќ… » ÷¬≈“ј ќ–»≈Ќ“»–ќ¬јЌЌќ√ќ “≈Ќ≈¬ќ√ќ √–јƒ»≈Ќ“ј ќЅЋј ќ¬ (EG)
// Ќачальный минимальный коэффициент ¤ркости теневых участков облака.
 static const float SetVS30 = 0.00 ; //
// ”ровень минимальной базовой детализации теней на основе fIntensity
 static const float SetVS31 = 0.35 ; //
// ”ровень ¤ркости освещенных участков при максимальном положении —олнца в зените.
 static const float SetVS32 = 1.50 ; //
// ”ровень ¤ркости освещенных участков при очень низком положении —олнца.(боковое освещение)
 static const float SetVS33 = 2.00 ; //
// ”ровень ¤ркости освещенных участков при низком положении —олнца на солнечной оппозиции
 static const float SetVS33o = 2.30 ; //
//  оэффициент добавочной ¤ркости освещенных участков на директионале —олнца при очень низком положении —олнца.
 static const float SetVS340 = 0.80 ;  static const float SetVS34A = 0.65 ; // на малых высотах // на больших высотах
// ”ровень дополнительного усилени¤ бокового освещени¤ при низком положении —олнца.
 static const float SetVS35 = 0.00 ; //
// √амма-коэффициент разности освещенно-теневых участков функции ScatterDueToNormal при —олнце в зените.
 static const float SetVS36 = 1.0 ; //
// √амма-коэффициент разности освещенно-теневых участков функции ScatterDueToNormal при очень низком положении —олнца.
 static const float SetVS37 = 1.45 ; //
// ƒобавочный гамма-коэффициент  функции ScatterDueToNormal при очень низком положении —олнца.
 static const float SetVS38 = 1.3 ; //
// ƒобавочный(отрицательный) коэффициент падени¤ ¤ркости освещенных участков после захода —олнца.
 static const float SetVS39 = -0.30 ; //
// ѕозици¤ центра тангенсоиды при котором изменение падени¤ ¤ркости освещенных участков составл¤ет 50%
 static const float SetVS40t = -0.040 ; //
//  рутизна тангенсоиды падени¤ ¤ркости освещенных участков.
 static const float SetVS41t = 53 ; //

// Ќастройки контрастности финального градиента
// ”ровень контрастности измен¤етс¤ за счет изменени¤ ¤ркости вершин имеющих максимальную ¤ркость при некотором фиксированном уровне тЄмных тонов
// ѕредварительна¤ обработка Ѕј«ќ¬ќ√ќ ¬≈–“» јЋ№Ќќ√ќ √–јƒ»≈Ќ“ј ќЅЋј ќ¬ (colorVGB)
//  онтрастность в зависимости от положени¤ —олнца
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )
 static const float SetVS51a = 1.0 ;      static const float SetVS51e = 1.0 ;        static const float SetVS51s = 1.0 ;
// ”ровень минимальной ¤ркости сведени¤ контрастности.
 static const float SetVS51M = 0.50 ;

// ѕредварительна¤ обработка “≈Ќ≈¬ќ√ќ √–јƒ»≈Ќ“ј ќЅЋј ќ¬ (ColorE)
//  онтрастность в зависимости от положени¤ —олнца
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )
 static const float SetVS52a = 1.05 ;      static const float SetVS52e = 1.15 ;        static const float SetVS52s = 1.10 ;
// ”ровень минимальной ¤ркости сведени¤ контрастности.
 static const float SetVS52M = 0.50 ;

// ќбработка финального цвета (BcolorFinal)
//  онтрастность в зависимости от положени¤ —олнца на малых высотах ~< 1000 m
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )
 static const float SetVS53a = 1.0  ;      static const float SetVS53e = 1.0 ;        static const float SetVS53s = 1.15   ;
//  онтрастность в зависимости от положени¤ —олнца на больших высотах ~> 5000 m
 static const float SetVS80a = 1.0  ;      static const float SetVS80e = 1.0 ;        static const float SetVS80s = 1.15   ;
// ”ровень минимальной ¤ркости сведени¤ контрастности.
 static const float SetVS53M = 0.50 ;

// ”ровень теневой детализации при максимальном положении —олнца в зените.
 static const float SetVS55 = 0.45 ; //  0.35*0
// ”ровень общей теневой детализации при очень низком положении —олнца.(боковое освещение)
 static const float SetVS56 = 0.65 ;
//

// «адействование функции перехода от теневой детализации к дополнительной вертикальной детализации при очень низком положении —олнца.
// ”ровень дополнительного усилени¤ детализации базового вертикального градиента облаков при —олнце на горизонте.
 static const float SetVS57 = 0.0 ;
//  рутизна характеристики перехода к дополнительной вертикальной детализации
 static const float SetVS58 = 0.9 ;

//  оррекци¤ ¤ркости (добавочный коэффициент) на солнечной оппозиции при низком положении —олнца.
 static const float SetVS60 = 0.25 ;
//  оррекци¤ ¤ркости (добавочный коэффициент) на солнечной оппозиции при положении —олнца на горизонте.
 static const float SetVS60s = -0.1 ;

// »нтерпол¤ци¤ между стандартной и альтернативныой моделью расчета освещени¤ облаков на основе групп зат¤жек. 0 - альтернативна¤ модель. 1 - стандартна¤.

//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )               
 static const float SetVS61a = 1.00 ;      static const float SetVS61e = 0.8 ;        static const float SetVS61s = 0.90 ;
//  в солнечном секторе на малых высотах ~< 1000 m
 static const float SetVS62a = 1.00 ;      static const float SetVS62e = 0.09 ;       static const float SetVS62s = 0.09 ;
//  в солнечном секторе на больших высотах ~> 5000 m
 static const float SetVS63a = 1.00 ;      static const float SetVS63e = 0.09 ;       static const float SetVS63s = 0.09 ;

// ќбщий фактор подсветки на директионале —олнца функцией RedDueToN
 static const float SetVS65 = 0.50 ;
// ‘актор поворота к наблюдателю освещенных текстур (в непоср близости от —олнца) функции RedDueToN
 static const float SetVS66 = 1.0  ;

// Ёффект дополнительной подсветки вершин и подошвы на директионале —олнца (fcolorGSs).
// ќбщий коэффициент ¤ркости и толщины
 static const float SetVS71 = 1.55  ;
//  омпенсаци¤ ¤ркости в центре
 static const float SetVS73 = 0.0  ;
// ћаксимальный размах смещени¤ градиента
//             под —олнцем         //                над —олнцем (нижн¤¤ подсветка)
 static const float SetVS74 = -0.55  ;  static const float SetVS75 = -0.25  ;

// ‘актор ширины и контрастности краев
// при среднем положении —олнца   // при низком положении —олнца
 static const float SetVS76 = 1.15  ;  static const float SetVS77 = 1.20  ;
//  рутизна разграничени¤ вектора подсветки
 static const float SetVS78 = 25  ; //     

//  оррекци¤ финальной ¤ркости (diffuse)
 static const float SetVS99 = 1.20  ;  //     
//------------------------------------------------------------------------------------------------------------------------------------------

// Ќј—“–ќ… » “≈Ќ≈…
// –азмер теневых текстур
 static const float SetGSS1 = 0.65   ;  //     
// »нтенсивность теней
 static const float SetPSS1 = 0.75   ;  //     
// Ќастройка тонировани¤ дымкой
 static const float SetFog = 0.90   ;  //
 
// Ќј—“–ќ… » ѕ» —≈Ћ№Ќќ√ќ Ў≈…ƒ≈–ј (PS)
//*******************************************************************************************************************************

// ”ровень текстурной детализации по каналу RGB
 static const float SetPS00 = 0.55 ;

// ѕредварительна¤ настройка ¤ркости и гаммы перед теневым фильтром
// ѕредварительна¤ гамма вспомогательного цвета (M1)
 static const float SetPS01 = 1.0 ;  //     
// ѕредварительна¤ ¤ркость вспомогательного цвета (M1)
 static const float SetPS02 = 0.75 ;  //     
// ѕредварительна¤ гамма основного цвета  (M2)
 static const float SetPS03 = 0.80 ;  //     

// Ќастройки цветового синтеза

// Ќачальный уровень(—олнце в зените) общей цветовой интерпол¤ции облаков(цветовой окраски)
 static const float SetPS14 = 0.10 ;
//  онечные основные точки цветовой интерпол¤ции
//   омпонеты g, b дл¤ вершин
 static const float SetPS15g = 0.57 ;  //      // начальный g-коэффициент
 static const float SetPS16g = 0.22 ;  //      // добавочный g-коэффициент дл¤ среднего положени¤ —олнца
 static const float SetPS15b = 0.08 ;  //      // начальный b-коэффициент
//   омпонеты g, b дл¤ нижней части
 static const float SetPS17g = 0.55 ;  static const float SetPS17b = 0.08 ;
//  оррекци¤ GB-компонета цветофильтра дл¤ вершин
// Ќачальный коэффициент коррекции
 static const float SetPS18 = 1 ; //     
//  оэффициент коррекции при низком положении —олнца.
 static const float SetPS19 = 0.7 ; //     
// ƒополнительный конечный коэффициент коррекции после захода —олнца
 static const float SetPS20 = 1.1 ; //     

// ƒистанционные настройки
// ќбщий уровень покраснени¤ облаков на дальних дистанци¤х
 static const float SetPS21 = 0.3 ; //     
// ќбщий коэффициент окраски на  дальних дистанци¤х
 static const float SetPS22 = 0.2 ; //     
// ћаксимальные цветовые корректирующие интерпол¤торы дл¤ дальних дистанций
 static const float SetPS22r = 1.2 ; static const float SetPS22g = 0.6 ; static const float SetPS22b = 0.6 ;
//

//

// Ќасыщенность освещенных участков на различных высотах расположени¤ облака.
//  оэффициент насыщенности на больших высотах расположени¤ облака ( ~> 5.5 km )
 static const float SetPS40 = 1   ; //     
//  оэффициент насыщенности на больших высотах расположени¤ облака ( ~> 5.5 km ) при низком положении —олнца
 static const float SetPS41 = 0.75 ; //     
//  оэффициент насыщенности на малых высотах расположени¤ облака ( ~< 1.5 km )
 static const float SetPS42 = 1.15 ; //     

//   оэффициент добавочной насыщенности самых ¤рких участков
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )                
 static const float SetPS47a = 0.1 ;      static const float SetPS47e = 0.2 ;       static const float SetPS47s = 0.2 ;

//  ”ровень насыщенности финального цветосинтеза перед теневым фильтром
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )                
 static const float SetPS48a = 0.80 ;      static const float SetPS48e = 0.65 ;       static const float SetPS48s = 0.75 ;
// ‘ункци¤ удалени¤ красных ореолов по контуру облаков
 static const float SetPS49 = 0.5 ;

//----------------------------------------------------------------------------------------------------------------------------------------------
// Ќастройки сглаживающего теневого фильтра
// ќбщий корректируюший коэффициент уровн¤ теневого фильтра
 static const float SetPS54 = 1.38*0.7 ;
//  ”ровень теневого фильтра в сутках
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )                
 static const float SetPS55a = 1.00 ;      static const float SetPS55e = 0.70 ;       static const float SetPS55s = 0.55 ;
//            –анние сумерки         //   ѕоздние сумерки и  Ќочь
 static const float SetPS55d = 0.70 ;      static const float SetPS55n = 1.00 ;     
//  оэффициент компенсации ¤ркости теневого фильтра в сутках
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )
 static const float SetPS56a = 1 ;      static const float SetPS56e = 1 ;        static const float SetPS56s = 1 ;
//            –анние сумерки         //    ѕоздние сумерки и  Ќочь
 static const float SetPS56d = 1 ;      static const float SetPS56n = 1 ;   

// ÷ветова¤ гамма фильтра. Ѕазовые уровни цветовых компонентов.
//                   расный            //                   «елЄный              //                   —иний
 static const float SetPS57r = 0.20    ; static const float SetPS57g = 0.28      ;  static const float SetPS57b = 0.30 ;
// ”ровень цветовой насыщенности фильтра.
 static const float SetPS58 = 0.30    ; //     
// ќсновна¤ крутизна фильтра.
 static const float SetPS59 = 2.50    ; //     
// Ќастройка смещени¤ порогов фильтра
// ѕокомпонентна¤ коррекци¤ смещени¤  порогов фильтра
//                   расный            //                   «елЄный              //                   —иний
 static const float SetPS61r = 1.90    ; static const float SetPS61g = 1.50    ; static const float SetPS61b = 1.50    ;
// ќбща¤ насыщенность облаков до подсинивани¤
 static const float SetPS79 = 1.00    ; //     

// ”ровень общего подсинивани¤ финального цвета
 static const float SetPS80 = 0.65    ; //     
// ”ровень подсинивани¤ на ближних дистанци¤х в дол¤х от общего уровн¤
 static const float SetPS81 = 0.00    ; //     
// Ќастройка цвета подсинивани¤.(настройка компонентов rgb умножающими коэффициентами)
//                  красный          //                   зеленый          //                   синий   
 static const float SetPS82r = 0.65  ; static const float SetPS82g = 0.85  ; static const float SetPS82b = 1.00  ;

// ”ровень эффекта дополнительного подсвечивани¤ контуров текстур.(„резмерный эффект делает более выраженую гранул¤цию по силуэту облака)
 static const float SetPS10 = 0.00 ;  // ƒанный эффект расчитан на применение со специальными текстурами, в случае с обычными текстурами эффект должен = 0.   

// некомпенсированна¤  настройка предварительной ¤ркости под теневой фильтр
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )                
 static const float SetPS04a = 1.00 ;      static const float SetPS04e = 0.50 ;       static const float SetPS04s = 0.40 ;
//            –анние сумерки         //   ѕоздние сумерки и  Ќочь
 static const float SetPS04d = 0.35  ;      static const float SetPS04n = 0.40*1.5 ;  
// ќбща¤ настройка предварительной ¤ркости под теневой фильтр
 static const float SetPS05 = 0.65 ;  // 0.65   

// Ќастройка компенсации падени¤ ¤ркости на выходе теневого и цветового фильтра дл¤ общей стабилизации ¤ркости на выходе
// нормализаци¤ компенсирующего коэффициента ¤ркости
 static const float SetPS06 = 0.35 ;  //     
// уровень компенсации падени¤ ¤ркости на выходе фильтра // =0 - компенсаци¤ ¤ркости полностью отсутствует. =1 - полна¤ компенсаци¤.
 static const float SetPS07 = 0.0 ; //
// крутизна изменени¤ компенсации ¤ркости на выходе фильтра
 static const float SetPS08 = 0.5 ;  //     
// нижний порог ограничени¤ компенсации ¤ркости на выходе фильтра
 static const float SetPS09 = 0.1 ;  //     

 

//  оррекци¤ гаммы в солнечном секторе на закате и после заката(добавочный коэффициент)
 static const float SetPS85 = 0.3   ;
//  оррекци¤ ¤ркости в солнечном секторе на закате и после заката(добавочный коэффициент)
 static const float SetPS86 = 0.00  ;
//

// ќбща¤ дневна¤ ¤ркость облаков на выходе
 static const float SetPS90 = 1.20*1.35    ; //     
// ќбща¤ ночна¤ ¤ркость облаков на выходе
 static const float SetPS91 = 0.025   ; //     
//  оррекци¤ ¤ркости облаков на выходе в сутках
//            —олнце в зените        //   —олнце не очень низко над горизонтом   //  —олнце на горизонте ( закат/восход )                
 static const float SetPS93a = 0.80 ;      static const float SetPS93e = 1.10 ;       static const float SetPS93s = 1.37 ;
//            –анние сумерки         //   ѕоздние сумерки и  Ќочь
 static const float SetPS93d = 1.50  ;      static const float SetPS93n = 0.70 ;     

// ќбща¤ насыщенность облаков на выходе
 static const float SetPS94 = 0.99    ; //   
// Ќастройки альфа-канала
// ѕрозрачность облаков на ближних дистанци¤х
 static const float SetPS97 = 1.00    ; //  
// ѕрозрачность облаков на дальних дистанци¤х (јнтипопкорн)
 static const float SetPS98 = 0.55    ; //  
//  рутизна сглаживани¤ альфа-канала
 static const float SetPS99 = 1.70    ; //  
// –езерв =================================================================================================================
// —мещение высоты потемнени¤ подошвы и нижней части облаков м
 static const float SetC11 = 200 ; //
// ћинимальна¤ ¤ркость подошвы и ¤ркость отсечени¤ минимальных ¤ркостей нижниих частей.
 static const float SetC12 = 0.480 ; //

//***************************************************************************************************************************************
//***************************************************************************************************************************************

 static const float Sundy  = cb_mSun.mDirection.y ; //
 static const float Sundx  = cb_mSun.mDirection.x  ; //
 static const float Sundz  = cb_mSun.mDirection.z  ; //
 static const float Moondy = cb_mMoon.mDirection.y ; //
 static const float Moondx = cb_mMoon.mDirection.x ; //
 static const float Moondz = cb_mMoon.mDirection.z ; //

 static const float ALtit1 = cb_Altitude/10000  ;
 float FAcorrP( float xAltHmax, float Sc )
  { return saturate(1-step(0, -(ALtit1-xAltHmax))*pow(abs((ALtit1-xAltHmax)/xAltHmax), Sc)) ; }
 float FAexpP( float xWa, float Sc )
    { return 1-exp(-pow(abs( xWa *ALtit1 ), Sc )) ; }
 static const float HAoffset = step( 0, ALtit1)*(0.051*exp(log(abs(ALtit1))/1.77)-0.0022*exp(log(abs(ALtit1))/1.1))  ;
 static const float VisSunOn = saturate((Sundy+HAoffset+0.04 )*15 ) ;

 static const float fAcorr22 = FAcorrP( 2.0, 2.0 );  static const float fAcorr_22 = 1-fAcorr22 ;
 static const float fAcorr23 = FAcorrP( 2.0, 3.0 );  static const float fAcorr_23 = 1-fAcorr23 ;
 static const float fAcorr24 = FAcorrP( 2.0, 4.0 );  static const float fAcorr_24 = 1-fAcorr24 ;
 static const float fAcorr26 = FAcorrP( 2.0, 6.0 );  static const float fAcorr_26 = 1-fAcorr26 ;
 static const float fAcorr28 = FAcorrP( 2.0, 8.0 );  static const float fAcorr_28 = 1-fAcorr28 ;

 static const float fAexp23 = FAexpP( 2, 3 ) ;   static const float fAexp24 = FAexpP( 2, 4 ) ;
 static const float fAexp33 = FAexpP( 3, 3 ) ;   static const float fAexp34 = FAexpP( 3, 4 ) ;
 static const float fAexp43 = FAexpP( 4, 3 ) ;   static const float fAexp44 = FAexpP( 4, 4 ) ;
 static const float fAexp53 = FAexpP( 5, 3 ) ;   static const float fAexp84 = FAexpP( 8, 4 ) ;
 static const float fAexp83 = FAexpP( 8, 3 ) ;

 static const float FACorE1 = fAexp53*fAexp53 ;

 static const float FACorR4 = saturate( tanh(2.8*ALtit1) )  ;  static const float FACorR_4 = 1-FACorR4 ; //  
 static const float FACorR1 = saturate(1-exp(-3.0*ALtit1))  ;  static const float FACorR_1 = 1-FACorR1 ; //   

 static const float ProcessDE0 = saturate(0.5+0.5*tanh(5*(Sundy-0.50 ))) ;  static const float Process_DE0 = 1-ProcessDE0 ;
 static const float ProcessDE1 = saturate(0.5+0.5*tanh(7*(Sundy-0.50 ))) ;  static const float Process_DE1 = 1-ProcessDE1 ;
 static const float ProcessDE2 = saturate(0.5+0.5*tanh(8*(Sundy-0.33 ))) ;  static const float Process_DE2 = 1-ProcessDE2 ;
 static const float ProcessDE5 = saturate(0.5+0.5*tanh(35*(Sundy-0.15 ))) ;  static const float Process_DE5 = 1-ProcessDE5 ;
 static const float ProcessD_E5 = saturate((0.5+0.5*tanh(-12*(Sundy-0.65 )))*1.03) ;  static const float Process_D_E5 = 1-ProcessD_E5 ;
 static const float ProcessDT1 = saturate( tanh(11*Sundy )) ;  static const float ProcessDT_1 = 1-ProcessDT1 ;
 static const float ProcessSF1 = ProcessDE5*ProcessD_E5 ;
 static const float ProcessSn1 = saturate(1- (1- pow(abs( (Sundy- 1 )/(1-0.35)), 2 ))*(1-exp(-pow(abs( 5.5 *(Sundy-0.35)), 2)))) ;

 static const float ProcessDES = saturate(1.021*(0.5+0.5*tanh( 35*( Sundy - 0.06 )))-0.02) ; static const float Process_DES = 1-ProcessDES ;
 static const float PReProcessE  = saturate(1.025*(0.5+0.5*tanh(20*(Sundy-0.11 )))-0.02) ; //  
 static const float PReProcess_E = 1-PReProcessE ;
 static const float PReProcessE2  = saturate( 1.01* ( 1-exp(-pow(abs( 8 *Sundy ), 2.5  )) )*tanh( 4*Sundy)) ; static const float PReProcess_E2 = 1-PReProcessE2 ;//  
 static const float PReProcessEDES  = lerp(ProcessDE2, ProcessDES, SetVS58 ) ; static const float PReProcess_EDES = 1-PReProcessEDES ;
 static const float PReProcessEE  = saturate(tanh( 11 * Sundy)*((0.5+0.5*tanh( -7 *(Sundy- 0.50 )))*1.05-0.02) ) ;
 static const float PReProcessES1  = saturate(1-pow(abs((Sundy-0.1)/0.1), 3)*step(0, -(Sundy-0.1)) ) ;
 static const float PReProcessEt   = saturate(1.025*(0.5+0.5*tanh(20*(Sundy-0.11 )))-0.02) ;
 static const float PReProcess_Et = 1-PReProcessEt ;
 static const float PReProcessEGt =  saturate( 1.003*(1-exp(-pow(abs( 18 *(Sundy+0.03)), 3 )))*exp(-pow(abs( (5-2)*(Sundy+0.03)), 3 )))*step(0, (Sundy+0.03)) ;

 static const float PReProcessEG =  saturate( 1.003*(1-exp(-pow(abs( 18 *(Sundy+0.03)), 3 )))*exp(-pow(abs( (5-2)*(Sundy+0.03)), 3 )))*step(0, (Sundy+0.03)) ;
 static const float PReProcessEG1 =   saturate(tanh( 11 * Sundy)* exp(-pow(abs( 8 *(Sundy - 0.35)), 2.5 ))) ;
 static const float Sxoffs1 = 0.10 ;  static const float SfDy = Sundy-Sxoffs1 ;
 static const float ScEs = 4 ;
 static const float ScWea = 2.3 ;
 static const float PReProcessEG2 = step(0, -SfDy)*saturate(1-pow(abs(SfDy/Sxoffs1), ScEs)) + step(0, SfDy)* exp(-pow(abs(ScWea *SfDy), 3 )) ;

 static const float POstProcessD0 = saturate(0.5+0.5*tanh(28*(Sundy+0.08 ))) ;        static const float POstProcess_D0 = 1-POstProcessD0 ;
 static const float POstProcessD1 = saturate(1.0* (0.5+0.5*tanh(35*(Sundy+0.085)))) ; static const float POstProcess_D1 = 1-POstProcessD1 ;

 static const float POstProcessB0 = saturate(0.5+0.5*tanh(35*(Sundy+0.095 ))) ;       static const float POstProcess_B0 = 1-POstProcessB0 ;
 static const float POstProcessB1 = saturate(0.5+0.5*tanh(33*(Sundy+0.15  ))) ;       static const float POstProcess_B1 = 1-POstProcessB1 ;
 static const float POstProcessS1 = saturate(1*(0.5+0.5*tanh(50*(Sundy+0.050))))    ; static const float POstProcess_S1 = 1-POstProcessS1 ;
 static const float POstProcessS2 = saturate(0.5+0.5*tanh(55*(Sundy-0.05  ))) ;       static const float POstProcess_S2 = 1-POstProcessS2 ;
 static const float POstProcessS3 = saturate(0.5+0.5*tanh(53*(Sundy-SetVS40t ))) ;          static const float POstProcess_S3 = 1-POstProcessS3 ;

float FProcessF(in float xDA, in float xEG, in float xSU )
               { return lerp(lerp( xSU, xDA, PReProcessE ), xEG, PReProcessEG) ; }

 static const float aSetC9H = lerp(SetVS3H, 0, FACorE1 ) ;
 static const float cSetVS61 = lerp(FProcessF( SetVS61a, SetVS61e, SetVS61s ), 1, POstProcess_S3  )  ;
 static const float cSetVS620 = lerp(FProcessF( SetVS62a, SetVS62e, SetVS62s ), 1, POstProcess_S3  )  ;
 static const float cSetVS63A = lerp(FProcessF( SetVS63a, SetVS63e, SetVS63s ), 1, POstProcess_S3  )  ;
 static const float cSetVS62 = lerp(cSetVS620, cSetVS63A, fAcorr28  )  ;
 static const float cSetPS55 = lerp(lerp(FProcessF( SetPS55a, SetPS55e, SetPS55s ), SetPS55d,  POstProcess_S1), SetPS55n, POstProcess_B1) ;
 static const float cSetPS56 = lerp(lerp(FProcessF( SetPS56a, SetPS56e, SetPS56s ), SetPS56d,  POstProcess_S1), SetPS56n, POstProcess_B1) ;
 static const float cSetPS04 = lerp(lerp(FProcessF( SetPS04a, SetPS04e, SetPS04s ), SetPS04d,  POstProcess_S1), SetPS04n, POstProcess_B1) ;
 static const float cSetPS93 = lerp(lerp(FProcessF( SetPS93a, SetPS93e, SetPS93s ), SetPS93d,  POstProcess_S1), SetPS93n, POstProcess_B1) ;

    float RIntGc( float fIntGB )
     {  const float Sud    = 4   ;  //         
        const float IntSud = 0.0   ;  //         
        const float IntLc  = 0.5   ;  //          
        const float IntTn0 = 3  ;  //
        float UpScf = saturate(1-pow(abs(fIntGB-1), Sud) ) ;  float DwScf = saturate( pow(abs(fIntGB), 1/Sud) ) ;
        return fIntGB - IntLc*(saturate(tanh(IntTn0*fIntGB)) *(lerp(UpScf, DwScf, IntSud)-fIntGB)) ;
     }

//perObject
shared cbuffer cbPerObjectCloudData : REGISTER(b,PER_MATERIAL_CB_REGISTER)
{
    float   fAlpha :                                packoffset(c0.x);
    float   fAlphaEdges :                            packoffset(c0.y);
    float   fRadius :                                packoffset(c0.z);
    float   fCloudExpandScale :                     packoffset(c0.w);

    float   fCloudExpandDistance :                  packoffset(c1.x);
    float   fCloudFadeDistanceInverse :             packoffset(c1.y);
    float   fCloudFadeDistance :                    packoffset(c1.z);
    float   ColorLevelHeightLow :                    packoffset(c1.w);

    float   ColorLevelHeightMediumLow :                packoffset(c2.x);
    float   ColorLevelHeightMedium :                packoffset(c2.y);
    float   ColorLevelHeightMediumHigh :            packoffset(c2.z);
    float   ColorLevelHeightHigh :                    packoffset(c2.w);

    float   fCloudEndFadeDistance :                 packoffset(c3.x);
    float   fCloudExpandSizeScale :                 packoffset(c3.y);
    float   fFiller0 :                              packoffset(c3.z);
    float   fFiller1 :                              packoffset(c3.w);

    float4  ColorLevelColors[MAX_COLOR_LEVELS] :    packoffset(c4);
    
};

struct VS_OUTPUT
{
    float4x4 position : POSITION;
    float4x4 diffuse : COLORS;
    float4 uv : TEXCOORD;
    float fFogDistance : FOG;
    float4 mAlt : ALTITUDE;
};

struct GS_OUTPUT
{
    float4 position : SV_POSITION;
    float2 uv : TEXCOORD;
    float2 localUV : TEXCOORD2;
    
    #if defined(SHD_VIEW_SHADOW)
        float z : SHADOWZ;
    #else
        float mAlt : ALTITUDE;
        float4 diffuse : COLOR;
        float fFogDistance : FOG;
    #endif

    #if defined(SHD_GS_INSTANCING)
        uint RTIndex : SV_RenderTargetArrayIndex;
    #endif
};

struct PS_INPUT
{
    float4 position : SV_POSITION;

    float2 uv : TEXCOORD;
    float2 localUV : TEXCOORD2;
   
    float mAlt : ALTITUDE;
    float4 diffuse : COLOR;
    float fFogDistance : FOG;
};

void GetScreenQuadPositions( out float4x3 output, in float width, in float height )
{
    float halfWidth = width;
    float halfHeight = height;
    /// VALUE // Quadrant
    output[0].x = -halfWidth;   //-1
    output[0].y = -halfHeight;  //-1
    output[0].z = 0;

    output[1].x =  halfWidth;   // 1
    output[1].y = -halfHeight;  //-1
    output[1].z = 0;

    output[2].x = -halfWidth;   // -1
    output[2].y =  halfHeight;  //  1
    output[2].z = 0;

    output[3].x = halfWidth;    // 1
    output[3].y = halfHeight;   // 1
    output[3].z = 0;
}

float ComputeScatterFactor(float3 vNormal, float3 cameraDir, float3 lightDirection, float fViewDependency)
{
    //vNormal = -vNormal;

    // how much is the camera looking into the light source?
    float fBackContribution = (dot(-cameraDir, lightDirection) + 1.0) * 0.5;

    // compute the result to get the right falloff
    fBackContribution *= fBackContribution;
    fBackContribution *= fBackContribution;

    // use the reverse normal to compute scatter
    float fScatterDueToNormal = (dot(-lightDirection, -vNormal) + 1.0) * 0.5;

    // choose between scatter and back contribution based on artist-controlled parameter
    float fScatterFactor = lerp(fScatterDueToNormal, fBackContribution, fViewDependency);

    // back it off based on how much cloud is in the way
    float fReductionDueToNormal = (dot(-cameraDir, vNormal) + 1.0) * 0.5;
    fScatterFactor *= fReductionDueToNormal;

    return fScatterFactor;
}

void ComputeFarAndNearFade(in out float4 position, in out float4 diffuse)
{
    // Calculate fade distance and alpha
    float fFadeDistance = position.w;
    fFadeDistance = min(fFadeDistance, fCloudFadeDistance);
    fFadeDistance -= fCloudEndFadeDistance;

    float fOneOverRange = rcp(fCloudFadeDistance - fCloudEndFadeDistance);
    float fAlphaFade = fFadeDistance * fOneOverRange;

    /// Apply fading at the far clip. This prevents clouds popping in/out at the far clip
#if defined(SHD_FADE_AT_FAR_CLIP)
    fAlphaFade = FarClipAlphaFade(position.w, fAlphaFade);
#endif

    /// Apply a distance fade relative to the camera
    diffuse.w *= fAlphaFade;

    bool bOverrideZ = (position.w < cb_NearClip);
    bOverrideZ = bOverrideZ && (position.w > fCloudEndFadeDistance);

    position.z *= !bOverrideZ;

    float fUseNear = cb_NearClip * bOverrideZ;
    position.w = position.w * !bOverrideZ + fUseNear;
}

void GetPointDiffuse( out float4 diffuse, in float3 corner, in float3 fvNormal,  in float3 fvPosition,  in float cloudDistance, in float3 facingDir,
                      in float3 nPosition1, in float3 nPosition2,  in float3 nPosition3,  in float3 VecEx , in matrix matWorld2 )
{
 // float3 nPosition1 = normalize(Position1) ;  float3 nPosition2 = normalize(Position2) ;  float3 nPosition3 = normalize(Position3) ;
    const float fExp32 = saturate(exp(  SetVS3S* (cloudDistance - SetVS3D*0.9 )));
    const float MdistFac = 0.5*1.5*cloudDistance/200000 ;
    const float fExp_P =  saturate(1-exp(-pow(abs(0.7*1.8*( MdistFac-1)), 5)))*step(0, -( MdistFac-1)) ; //  saturate(1-pow(abs(MdistFac), 1 )  )           
    const float fExpP = 1-fExp_P ;
  float4 RotAzProj = mul( float4(VecEx,1.0), matWorld2 )   ;   //    

 

  float3 AngPosVec = normalize( RotAzProj.xyz ) ;    //  
  float3 AngWSAVec = normalize( float3(RotAzProj.x,   RotAzProj.y+ cb_Altitude,    RotAzProj.z )) ;    //  
    const float fAngY1 = saturate(pow(abs(AngPosVec.y), 0.5 ) ) ;      const float fAng_Y1 = 1 - fAngY1 ;
  const float P_i = 3.1415926536 ;  const float PiU2 = 6.2831853072 ; const float Pi_2 = 1.5707963268 ;
  float AzRDx = (step(0,  AngPosVec.z)*step(0,  AngPosVec.x)* 0.25* atan(abs(( AngPosVec.x )/( AngPosVec.z )) )/Pi_2
               + step(0, -AngPosVec.z)*step(0,  AngPosVec.x)*( 0.25*atan(abs(( AngPosVec.z )/( AngPosVec.x )) )/Pi_2+0.25 )
               + step(0, -AngPosVec.z)*step(0, -AngPosVec.x)*( 0.25*atan(abs(( AngPosVec.x )/( AngPosVec.z )) )/Pi_2+0.5  )
               + step(0,  AngPosVec.z)*step(0, -AngPosVec.x)*( 0.25*atan(abs(( AngPosVec.z )/( AngPosVec.x )) )/Pi_2+0.75 ))  ; //

  float SundirX = (round(Sundx*100000)+0.1)/100000 ;
  float MoondirX = (round(Moondx*100000)+0.1)/100000 ;
  float AangleSUN =  1-(step(0, Sundz)*step(0, -Sundx) +0.5*step(0, Sundx) +atan(Sundz/SundirX )/PiU2)-0.25   ;
  float AangleMoon = 1-(step(0, Moondz)*step(0, -Moondx) +0.5*step(0, Moondx) +atan(Moondz/MoondirX )/PiU2)-0.25 ;
  float AngleSC = (AangleSUN+0.5)*2*P_i ;  float ASsin = sin(AngleSC) ;  float AScos = cos(AngleSC) ;
  const float asun = AzRDx - AangleSUN   ; const float amoon = AzRDx - AangleMoon   ;     //  
  const float asun1 = asun+1 ; const float asun_1 = asun-1 ; const float asunO1 = asun+0.5 ; const float asun_O1 = asun-0.5 ;
  const float angsunY =  AngPosVec.y - cb_mSun.mDirection.y ;

  float TempSUNYZ = 1-exp(-pow(abs( 2.5*(AngPosVec.y -1)), 2.5 ))   ;
  float TempSUNY1 = exp(-pow(abs( 3.5*angsunY), 2 ))   ;
  float TempSUNYm = exp(-pow(abs( 11*angsunY), 1.5 ))   ;
  float TempSUNR1 = (1-(1-exp(-pow(abs( 11*asun), 3)) )*(1-exp(-pow(abs( 11*asun1), 3)) )*(1-exp(-pow(abs( 11*asun_1), 3) ) ))  ;
  float TempSUNR2 = (1-(1-exp(-pow(abs( 8*asun), 3)) )*(1-exp(-pow(abs( 8*asun1), 3)) )*(1-exp(-pow(abs( 8*asun_1), 3) ) ))  ;
  float TempSUNR3 = (1-(1-exp(-pow(abs( 3*asun), 3)) )*(1-exp(-pow(abs( 3*asun1), 3)) )*(1-exp(-pow(abs( 3*asun_1), 3) ) ))  ;
  float TempSUNR4 = (1-(1-exp(-pow(abs( 5*asun), 4)) )*(1-exp(-pow(abs( 5*asun1), 4)) )*(1-exp(-pow(abs( 5*asun_1), 4) ) ))  ;

  float TempSUNRm = (1-(1-exp(-pow(abs( 17*asun), 1.7)) )*(1-exp(-pow(abs( 17*asun1), 1.7)) )*(1-exp(-pow(abs( 17*asun_1), 1.7) ) ))  ;
  float TempSUNR_O1 = (1-exp(-pow(abs( 3*asunO1), 3)) )*(1-exp(-pow(abs( 3*asun_O1), 3)) )   ;
  float TempSUNRO1 = 1-saturate(TempSUNR_O1) ;
  float TempSUNR_O2 = (1-exp(-pow(abs( 7*asunO1), 2)) )*(1-exp(-pow(abs( 7*asun_O1), 2)) )   ;
  float TempSUNRO2 = 1-saturate(TempSUNR_O2) ;

  float TempFullS1 = TempSUNY1*TempSUNR1 ;  //   
  float TempFullSm = TempSUNYm*TempSUNRm ;  //

  float TempAngHY1 =  saturate( exp(-11*AngWSAVec.y)) ;
  float Roxz1 =   nPosition1.x*ASsin + nPosition1.z*AScos    ;  //  
  float Roxz2 =   nPosition2.x*ASsin + nPosition2.z*AScos   ;  //  
  float Roxz3 =   nPosition3.x*ASsin + nPosition3.z*AScos   ;  //  

  float kSoff1 = lerp( 0.4, 0.2, fAcorr28 ) ;
  float kSoff2 = lerp( 0.45, 0.25, fAcorr28 ) ;

  float fSoffset = kSoff1-kSoff2*TempSUNRO1 -0.25*TempSUNR3*(1-exp(-5*abs(AngPosVec.y-saturate(Sundy)))) ; //                   
  float TempXZ1 = saturate(0.5+0.5*tanh( -5* (Roxz1  +  fSoffset  )))  ;  // saturate(  saturate(1- nPosition1.y)-fA0 ) *

  float TempXZ2 = saturate(0.5+0.5*tanh(2* (Roxz2  + 1   ))) ;   //  saturate(pow(abs(0.5+0.5*Roxz2), 2 ))

 

  float HAcompY = RotAzProj.y+ cb_Altitude +3100*pow(abs(cloudDistance/200000), 2 ) +1.1*aSetC9H*SetVS3*fExp32 ;
  float hCAltitudeY1 = HAcompY/10000 ;
  float fIntAltCorr1 = (1-exp(-pow(abs( 4 * hCAltitudeY1), 3.5)))*saturate(tanh( 2.2 *hCAltitudeY1))  ;
  float3 groupCenter = lerp(  fvNormal, fvPosition, lerp(cSetVS61, cSetVS62, 0.2*TempSUNR2 ) ) ;

//-----------------------------------------------------------------------------------------------------------------------------------------------

    // Sun lighting
    // See bglfp.cpp, g2d_LightCloudFromNormal() - KEEP SHADER IN SYNC!

    float3 ActiveLightDirectionSM = lerp(cb_mSun.mDirection, cb_mMoon.mDirection, POstProcess_B1) ;
    float3 cloudGroupNormal = normalize( corner.xyz - groupCenter + float3(0, fExp32*0.9*aSetC9H, 0) );
    float3 facingDirection = cross( cloudGroupNormal, float3( 0, 1, 0 ) );
    float3 lightDirection = float3(ActiveLightDirectionSM.x,  saturate(ActiveLightDirectionSM.y),  ActiveLightDirectionSM.z)  ;
    float  fIntensity = -1.0f * max(dot(lightDirection, cloudGroupNormal), dot(lightDirection, facingDirection));

    if (fIntensity < -cb_mMedianLine)
    {
        // The "1.0001" in the line above is a hack to fix a bug
        // observed on some hardware. Even though the else branch
        // of this if/else was taken a divide by zero in this
        // branch (when cb_mMedianLine is 1.0) caused the whole
        // shader to go crazy.
        fIntensity = cb_mMinIntensity + ((cb_mMedianIntensity - cb_mMinIntensity) *    ((1 + fIntensity) / (1.0001 - cb_mMedianLine)));
    }
    else
    { fIntensity = cb_mMedianIntensity +(1 - cb_mMedianIntensity) *(fIntensity + cb_mMedianLine) / (1 + cb_mMedianLine); }

 

    // Height band lighting/coloring
    // See SwarmCloud.cpp, GetColor() - KEEP SHADER IN SYNC!
    float height =  corner.y    ;  //
    float4 baseColor;
    float4 topColor;
    float  baseHeight;  
    float  topHeight;  

      float  height2 = height    ;   // - fofss2  + ShDizx*100      + 1.2*aSetC9H*SetVS3*fExp32           
    
    if (height2 <= ColorLevelHeightLow)
    {   baseColor  = ColorLevelColors[0]; topColor   = ColorLevelColors[0];
        baseHeight = ColorLevelHeightLow; topHeight  = ColorLevelHeightLow + 1 ; } // +1 to avoid division by zero below
    else if (height2 <= ColorLevelHeightMediumLow)
    {   baseColor  = ColorLevelColors[0]; topColor   = ColorLevelColors[1];
        baseHeight = ColorLevelHeightLow; topHeight  = ColorLevelHeightMediumLow; }
    else if (height2 <= ColorLevelHeightMedium)
    {   baseColor  = ColorLevelColors[1]; topColor   = ColorLevelColors[2];
        baseHeight = ColorLevelHeightMediumLow; topHeight  = ColorLevelHeightMedium; }
    else if (height2 <= ColorLevelHeightMediumHigh)
    {   baseColor  = ColorLevelColors[2]; topColor   = ColorLevelColors[3];
        baseHeight = ColorLevelHeightMedium; topHeight  = ColorLevelHeightMediumHigh; }
    else if (height2 <= ColorLevelHeightHigh)
    {   baseColor  = 1.0*ColorLevelColors[3]; topColor   = ColorLevelColors[4];
        baseHeight = ColorLevelHeightMediumHigh; topHeight  = ColorLevelHeightHigh; }
    else
    {   baseColor  = ColorLevelColors[4];  topColor   = ColorLevelColors[4];
        baseHeight = ColorLevelHeightHigh; topHeight  = ColorLevelHeightHigh + 1 ; } // +1 to avoid division by zero below    

    float heightE = nPosition2.y     ;  //  
    float  baseHeightE;  
    float  topHeightE;   
    if (heightE <= ColorLevelHeightLow)
    { baseHeightE = ColorLevelHeightLow ; topHeightE  = ColorLevelHeightLow + 100 ; } // +1 to avoid division by zero below
    else if (heightE <= ColorLevelHeightMediumLow)
    { baseHeightE = ColorLevelHeightLow ; topHeightE  = ColorLevelHeightMediumLow; }
    else if (heightE <= ColorLevelHeightMedium)
    { baseHeightE = ColorLevelHeightMediumLow ; topHeightE  = ColorLevelHeightMedium; }
    else if (heightE <= ColorLevelHeightMediumHigh)
    { baseHeightE = ColorLevelHeightMedium ; topHeightE  = ColorLevelHeightMediumHigh; }
    else if (heightE <= ColorLevelHeightHigh)
    { baseHeightE = ColorLevelHeightMediumHigh ; topHeightE  = ColorLevelHeightHigh; }
    else
    { baseHeightE = ColorLevelHeightHigh; topHeightE  = ColorLevelHeightHigh + 1000 ; } // +1 to avoid division by zero below    

    float VthicknessE = (topHeightE - baseHeightE ) ;
    float Vthickness = (topHeight - baseHeight ) ;

    float ofsBasTop = 0.5      ;   //   
    float st = saturate(  (height2 - baseHeight) / Vthickness - ofsBasTop   ) ;

    float s = saturate(  (height2 - baseHeight) / Vthickness) ;
    float colorA = lerp( baseColor.a, topColor.a, s  );  //  1.002*
//---------------------------------------------------------------------------------------------------------------------------------------------
    const float fCcolorBase = 1*lerp(1, 1,     fAngY1 ) ;
    const float fCcolorTop  = 4  ;    //  
  const float fcolorC = 1.8  ;              

    baseColor.rgb = fCcolorBase*pow(abs(baseColor.rgb), 1.0 ) ; // *float3(1, 1, 1 )
    topColor.rgb  = fCcolorTop *pow(abs( topColor.rgb), 1.0 ) ; // *float3(1, 1, 1 )
    float colorB = lerp( baseColor.r, topColor.r, pow(abs(st), 2 ) ); //
           colorB = pow(abs(colorB), 2   ) ; //
    float TrA = step(0, 0.1*baseHeight+1000*0.28) ;  // расчет ограничени¤ потемнени¤ подошвы, и текстур ниже подошвы (дополнительно по альфа-каналу : colorA = colorA*TrA ; )
    colorB  = fcolorC*clamp(colorB , SetC12, 5)   ;  // ограничение потемнени¤ подошвы, и текстур ниже подошвы
//----------------------------------------------------------------------------------------------------------------------------------------

    // Fade in/out alpha
    float distance_from_center = length(corner);
    float alpha = 1.0f;
 
    if (fAlpha > 0)
    {  // Fading in from or out to the edges
        float fMagnitude = 1.3f * fRadius - distance_from_center;
        fMagnitude = max(0, fMagnitude);
        alpha = fAlpha - fAlphaEdges * (fMagnitude / fRadius);
    }
    else
    {   // Fading out to the core
        alpha = -fAlpha - fAlphaEdges * (distance_from_center / fRadius);
    }
 
       const float fExp = saturate(exp(-cloudDistance * cloudDistance * 0.00000000077));

  float tempHYc =  1-saturate(exp(-44* abs(  AngWSAVec.y   ))) ; //  AngPosVec.y   
  float AngRCs = SetVS66*TempFullSm ;
  float3 facingDirE = float3(facingDir.z, facingDir.y, facingDir.x )  ;
  float RedDueToNs = saturate((dot(-facingDir, cloudGroupNormal) + 1) * 0.5 -0.1) ;
  float RedDueToNr = lerp( RedDueToNs, saturate((dot(-facingDirE, cloudGroupNormal) + 1) * 0.5 -0.2),  AngRCs ) ;
  float RedDueToNp = lerp( RedDueToNs, saturate((dot( facingDirE, cloudGroupNormal) + 1) * 0.5 -0.2),  AngRCs )  ;
  float RedDueToN = RedDueToNr*step(0, -facingDir.z ) + RedDueToNp*step(0, facingDir.z )     ;
  RedDueToN = pow(abs(RedDueToN), 2 ) ; RedDueToNs = pow(abs(RedDueToNs), 3 ) ;
  RedDueToN = SetVS65*( 0.8* RedDueToN*TempFullSm + 0.2* RedDueToNs*TempFullS1 )*lerp(1, saturate(nPosition2.y), 0.2 ) *POstProcessS2*tempHYc  ; //    

  float ScatterDueToNormal =  saturate( (dot(-lightDirection, -cloudGroupNormal ) + 1.0 )*0.50  ) ; // use the reverse normal to compute scatter
    ScatterDueToNormal = pow(abs(ScatterDueToNormal), lerp( SetVS36, SetVS37, TempSUNRO1*Process_DE0)+TempSUNR3*SetVS38*Process_DE0 ) ;    //   saturate        

    float ctBrL =   SetVS14*lerp( SetVS10, SetVS11, saturate(exp( -SetVS12* (VthicknessE-80)/1000  ))) ; // коэффициент крутизны градиента от толщины облачности
    float corrDistH = saturate(0.7*SetVS3H/5000) ;
     
    float fIntHVint1 = saturate(tanh( ctBrL *(nPosition1.y + corrDistH*fExp32  ) ))   ;  //
    float fIntHVint2 = saturate(tanh( ctBrL *(nPosition2.y + corrDistH*fExp32  ) ))   ;  //
    float fIntHVint =  lerp( fIntHVint2, fIntHVint1, lerp(SetVS15, SetVS57, SetVS57*PReProcess_EDES ) )  ;  //
    fIntHVint = pow( abs(fIntHVint), 1+11*TempFullS1 )+ SetVS13 + 0.3*fIntAltCorr1 -0.2*SetVS57*POstProcess_S3-0.2*PReProcess_E   ;

    float vecSune =  saturate(0.5+0.5*tanh(SetVS78 *(AngPosVec.y - Sundy ))) ;  //  
    float fIntHVint3 =  saturate(tanh( ctBrL *( (nPosition2.y + nPosition1.y) + corrDistH*fExp32  ) ))+lerp( SetVS75, SetVS74, vecSune ) ;  // pow(abs( 1*ctBrL *( nPosition1.y+nPosition2.y + corrDistH*fExp32 +1-2*fA0  ) ), 2.0 )
    float fcolorGSs = fIntHVint3*2*SetVS71 ;

    float LBcolor = lerp(SetVS20, SetVS21, fIntAltCorr1)   ; float HTcolor = lerp(SetVS22, SetVS22o, TempSUNRO2*Process_DE2*ProcessDES ) ;  float cIntcolor = SetVS23 ;

    float fCTcolor = 1.3 *saturate(HTcolor - LBcolor ) ;
    float colorVGB =  LBcolor +  fCTcolor* fIntHVint2*lerp(1, saturate(1 *fIntensity), cIntcolor )        ;  //       (1 - fA0* (1-saturate(fIntensity)))                  

    float corrMsp = 1+ 0.5*cSetVS61 ;
    float ColorE =  SetVS30 + (1+SetVS39* POstProcess_S3)*ScatterDueToNormal*corrMsp
                    *lerp(lerp(SetVS33, SetVS33o, TempSUNRO2*Process_DE2*ProcessDES ), SetVS32, ProcessDE0)
                    *(1+  lerp(SetVS340, SetVS34A, fAexp83)* TempSUNR2*Process_DE0 ) + SetVS31*saturate(fIntensity)    ;   //  *TempXZ1*1.5  lerp( 1.3,  0.4,  TempXZ1 )                     ScatterDueToNormal colorVGB *ScatterDueToNormal*1.0
    float ColorSD =  SetVS35 *PReProcessEG2*TempXZ1   ; //    
            
    float  ContrD = FProcessF( SetVS51a, SetVS51e, SetVS51s )  ;
    float  minLevD = SetVS51M  ;
    colorVGB = 1*(saturate(minLevD)+saturate(1-(minLevD))*pow(abs(ContrD), 3))*(1-ContrD*(1-colorVGB))  ;  //  
    float  ContrE = FProcessF( SetVS52a, SetVS52e, SetVS52s )  ;
    float  minLevE = SetVS52M  ;
    ColorE = 1*(saturate(minLevE)+saturate(1-(minLevE))*pow(abs(ContrE), 3))*(1-ContrE*(1-ColorE))  ;  //  

    float fIntEDDu = lerp(lerp( 1-lerp(saturate(SetVS56), 0, PReProcess_EDES*SetVS57 ), 1-saturate(SetVS55), ProcessDE0 ), 1, 0.2*TempSUNRO2*Process_DE0 )  ;

    float ContrSv = lerp( SetVS77, SetVS76, pow(abs(saturate(Sundy)), 0.5 ))  ;
    fcolorGSs = (saturate(0.35)+saturate(1-0.35)*pow(abs(ContrSv), 3))*(1-ContrSv*(1-fcolorGSs))  ;  //

    float BcolorFinal = lerp(  ColorE,  colorVGB,  lerp(fIntEDDu, 1, PReProcess_EDES*SetVS57) )+ RedDueToN + ColorSD ; //   

    float  ContrF0 = FProcessF( SetVS53a, SetVS53e, SetVS53s )  ;
    float  ContrFA = FProcessF( SetVS80a, SetVS80e, SetVS80s )  ;
    float  ContrF = lerp( ContrF0, ContrFA, fAcorr28 )  ;
    float  minLevF = SetVS53M  ;
    float AddVCSn2 = fcolorGSs*TempSUNR2*TempSUNYZ*(1+SetVS73*TempSUNR1)*(1+0.0 *TempFullSm )*POstProcessS1*ProcessSn1*(1-0.1*Process_DES)    ; //
    BcolorFinal = (1- (0.5*TempFullSm + 0.50*TempSUNR2*TempSUNYZ* Process_DE1 )*POstProcessB1  )
                 *(saturate(minLevF)+saturate(1-minLevF)*pow(abs(ContrF), 3))*(1-ContrF*(1-BcolorFinal)) + 1.0*AddVCSn2  ;  //  

    diffuse.r = SetVS99 *BcolorFinal*(1+TempSUNRO2*Process_DE2*fIntAltCorr1*lerp( SetVS60, SetVS60s, Process_DES) )   ; //       
    diffuse.g = TempSUNR2 ; //   TempSUNR2   colorVGB    fcolorGSs     PReProcessEG2
    diffuse.b = TempFullSm ; //                    
    diffuse.a =  colorA*saturate(alpha)  ;  

}  //  void GetPointDiffuse

// Generate a rotation matrix based on the bank, with 0 pitch and heading
float3x3 GenerateBankMatrix(in float b)
{
    float sin_b = sin(b);
    float cos_b = cos(b);

    float3x3 matRot;

    matRot[0].x = cos_b;
    matRot[1].x = -sin_b;
    matRot[2].x = 0;

    matRot[0].y = sin_b;
    matRot[1].y = cos_b;
    matRot[2].y = 0;

    matRot[0].z = 0;
    matRot[1].z = 0;
    matRot[2].z = 1;

    return matRot;
}

VS_OUTPUT VS(VS_INPUT In)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;

    float4 spriteCenter = In.vPosition;
    float3 groupCenter = In.vNormal.xyz;
    float4 packedUV = In.cColor;
    float2 packedCorner = In.Tex;
    float  bankRadian = In.fRBias[0];
    float  puffRadius = In.fRBias[1];

    GeoidTranform geoTrans = GetGeoidTranform(In.mInstanceIndex);

    // Get round world matrix
    matrix matWorld = ComputeRoundWorldMatrix(geoTrans, cb_ViewOrigin);

    // Set UV
    Out.uv = packedUV;

    // Offset the spritecenter with cluster offset. The cluster is a group of sprite to make up
    // a cloud. This is needed b/c sometime we draw one cluster at a time to do sorting
    float4 clusterOffset = GetCloudClusterOffset(In.mInstanceIndex);

    float3x3 rotationMatrix;

#if defined(SHD_VIEW_SHADOW)
    float3 shadowFacingVector = normalize(cb_mShadowLightDirection);

    rotationMatrix[2] = shadowFacingVector;
    rotationMatrix[0] = normalize(cross(rotationMatrix[2], float3(0, 1.0f, 0)));
    rotationMatrix[1] = normalize(-cross(rotationMatrix[2], rotationMatrix[0]));
#elif defined(SHD_VIEW_CUBEMAP) || defined(SHD_CLOUD_ALWAYS_CAMERA_FACE)
    // We baked a value [0 or 1] into the w component to tell us if this draw call is per puff
    int IsPuffDraw = saturate(clusterOffset.w);
    clusterOffset.w = 0.0;

//-----------------------------------------------------------------------------------------------------------------------------------
//    float3 positionVector = -mul(spriteCenter - clusterOffset, matWorld).xyz;
//    float3 cameraFacingVector = normalize(positionVector);
 

    float3 positionVector = -mul(spriteCenter - clusterOffset, matWorld).xyz;

     float cvcCFVi = 1 ; //  ===================================================

//    float3 cameraFacingVector = normalize(positionVector);   //----------------------------------------------
     float cloudDistance = length(positionVector);
    float cloudDistanceR = length(positionVector.xz);
    float3 cameraFacingVector1 = normalize(positionVector);  
    float3 cameraFacingVector = positionVector / cloudDistance; //+++++++++++++++++++++++++++++++++++++++++++++
    float3 PosOVec1 ;
//------------------------------------------------------------------------------------------------------------------------------------

 

    rotationMatrix[2] = normalize(cameraFacingVector);
    rotationMatrix[0] = normalize(cross(rotationMatrix[2], float3(0, 1, 0)));
    rotationMatrix[1] = normalize(-cross(rotationMatrix[2], rotationMatrix[0]));
#else
    // We baked a value [0 or 1] into the w component to tell us if this draw call is per puff
    int IsPuffDraw = saturate(clusterOffset.w);
    clusterOffset.w = 0.0;

//------------------------------------------------------------------------------------------------------------------------------------
    float3 positionVector = -mul(spriteCenter - clusterOffset, matWorld).xyz;
//    float3 cameraFacingVector = normalize(positionVector);  // --------------------------------------------------------

    float3 screenFacingVector = normalize(-cb_mInverseView[2].xyz);
    float cloudDistance = length(positionVector);
    float cloudDistanceR = length(positionVector.xz);
    float3 cameraFacingVector1 = normalize(positionVector);  
    float3 cameraFacingVector = positionVector / cloudDistance; //+++++++++++++++++++++++++++++++++++++++++++++
    float3 PosOVec1 ;
//-------------------------------------------------------------------------------------------------------------------------------------

 

    float blendDistance = 3000;  // Clouds will be fully volumize from 3000 meters, reducing to 0 at 6000

    float facingBlend = saturate(((blendDistance - cloudDistance) / blendDistance) * IsPuffDraw);

    rotationMatrix[2] = normalize(lerp(cameraFacingVector, screenFacingVector, facingBlend));
    rotationMatrix[0] = normalize(cross(rotationMatrix[2], float3(0, 1, 0)));
    rotationMatrix[1] = normalize(-cross(rotationMatrix[2], rotationMatrix[0]));
#endif

#if !defined(SHD_GS_INSTANCING)
    matrix worldView = mul(matWorld, cb_mViewToDevice);
#if defined(SHD_NO_NEAR_CLIP)
    matrix worldViewProj = mul(worldView, cb_mNoNearProj);
#elif defined(SHD_NO_FAR_CLIP)
    matrix worldViewProj = mul(worldView, cb_mNoFarProj);
#else
    matrix worldViewProj = mul(worldView, cb_mProjToDevice);
#endif
#endif

//--------------------------------------------------------------------------------------------------------
    float3 positionVector2 = -mul(spriteCenter - clusterOffset, matWorld).xyz;
    float cloudDistance2 = length(positionVector2);
    float cloudDistance2R = length(positionVector2.xz);
       const float fExp2 = saturate(exp(-cloudDistance2 * cloudDistance2 * 0.00000000077  ));
    const float fExp3 = saturate(exp(  SetVS3S* (  cloudDistance2 - SetVS3D*0.9 ))); //  
    const float kSizeC = saturate(SetVS1) ;  //
//----------------------------------------------------------------------------------------------------------

    //Apply the sprite bank rotation.
    rotationMatrix = mul(GenerateBankMatrix(bankRadian), rotationMatrix);

    Out.diffuse = (float4x4)0;

    float4x3 quad = (float4x3)0;
    float height = packedCorner.y;
    float width = packedCorner.x;
    GetScreenQuadPositions(quad, width*kSizeC, height*kSizeC  );

       const float fExpR = exp(-pow(abs( 0.1*50*cloudDistance2R/200000), 2)) ;
//    float iSetC8x = lerp(0.8*SetVS2x, 2, fExpR) ; float iSetC8z = lerp(2*SetVS2z, 1, fExpR) ;
    float iSetC8x = lerp(1*SetVS2x, 1, fExpR) ; float iSetC8z = lerp(1*SetVS2z, 1, fExpR) ;

    [unroll]for(int i = 0; i < 4; i++)
    {
        // Perform rotation
        float3 position = mul(quad.xyz, rotationMatrix )*float3( iSetC8x, SetVS2y, iSetC8z  )+float3( 0, -aSetC9H*SetVS3*fExp3, 0  )    ; //  
        /// Add the sprite center without scale to keep the diffuse color calculation identicle
        float3 position1 = normalize(position) ;  //    
        position = (spriteCenter.xyz + position  )   ; //  
        float3 position2 = normalize(position) ;  //
        float3 position3 = normalize(spriteCenter.xyz) ;  //  

#if defined(SHD_VIEW_SHADOW)
        position = -clusterOffset.xyz + position;
        Out.position = mul(float4(position, saturate(SetGSS1) ), matWorld);

    }
#elif defined(SHD_GS_INSTANCING)
        /// Calculate the lighting of the clouds based on position of each corner
//        GetPointDiffuse(Out.diffuse, position, spriteCenter.xyz, rotationMatrix[2]);

          PosOVec1 = 0 ;  //  position - clusterOffset.xyz

        GetPointDiffuse(Out.diffuse, position, In.vNormal.xyz, In.vPosition.xyz, cloudDistance, rotationMatrix[2],
                             position1, position2, position3, PosOVec1, matWorld );

        position -= clusterOffset.xyz;

        Out.position = mul(float4(position, 1.0), matWorld);
    }
#else
 
        /// Calculate the lighting of the clouds based on position of each corner
//        GetPointDiffuse( Out.diffuse, position, spriteCenter.xyz, rotationMatrix[2]);    

          PosOVec1 = position - clusterOffset.xyz  ;  //  

        GetPointDiffuse(Out.diffuse, position, In.vNormal.xyz, In.vPosition.xyz, cloudDistance, rotationMatrix[2],
                             position1, position2, position3, PosOVec1, matWorld  );

        /// Apply cluster offset and scale factor
        position -= clusterOffset.xyz;

        float4 worldPos = mul( float4(position,1.0), matWorld );
        Out.mAlt = worldPos.y;

        Out.position = mul( float4(position,1.0), worldViewProj );

        //Compute far and near fade for the position and diffuse.
        ComputeFarAndNearFade(Out.position, Out.diffuse);
    }
#endif

    #if !defined(SHD_VIEW_SHADOW)
        // Compute fog
        float3 vSpriteCenter = spriteCenter.xyz - clusterOffset.xyz;
        Out.fFogDistance = FogVS(float4(vSpriteCenter, 1), matWorld, float4(cb_mEyePoint.xyz, 1));
    #endif

    return Out;
}

#if defined(SHD_GS_INSTANCING)
[instance(SHD_GS_INSTANCE_COUNT)]
#endif
[maxvertexcount(4)]
void GS(point VS_OUTPUT input[1], inout TriangleStream<GS_OUTPUT> SpriteStream,
    uint InstanceID : SV_GSInstanceID)
{
    GS_OUTPUT output;
    
    float2 lowerleft = input[0].uv.xy;
    float2 upperright = input[0].uv.zw;

    #if defined(SHD_VIEW_SHADOW)
        output.RTIndex = InstanceID;

        // Bottom left
        output.position = mul(input[0].position[0], cb_mTranslucentViewProjection[InstanceID]);
        output.z = output.position.z;                            // pass down real z to PS
        output.position.z *= saturate(output.position.z); // pancake just in case
        output.uv.x = lowerleft.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Bottom right
        output.position = mul(input[0].position[2], cb_mTranslucentViewProjection[InstanceID]);
        output.z = output.position.z;                            // pass down real z to PS
        output.position.z *= saturate(output.position.z); // pancake just in case
        output.uv.x = lowerleft.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Top Left
        output.position = mul(input[0].position[1], cb_mTranslucentViewProjection[InstanceID]);
        output.z = output.position.z;                            // pass down real z to PS
        output.position.z *= saturate(output.position.z); // pancake just in case
        output.uv.x = upperright.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        // Top right
        output.position = mul(input[0].position[3], cb_mTranslucentViewProjection[InstanceID]);
        output.z = output.position.z;                            // pass down real z to PS
        output.position.z *= saturate(output.position.z); // pancake just in case
        output.uv.x = upperright.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        SpriteStream.RestartStrip();
    #elif defined(SHD_GS_INSTANCING)

        output.RTIndex = InstanceID;

#if defined(SHD_VIEW_CUBEMAP)
#if defined(SHD_NO_NEAR_CLIP)
        matrix viewProj = mul(cb_mViewCubemap[InstanceID], cb_mNoNearProj);
#elif defined(SHD_NO_FAR_CLIP)
        matrix viewProj = mul(cb_mViewCubemap[InstanceID], cb_mNoFarProj);
#else
        matrix viewProj = mul(cb_mViewCubemap[InstanceID], cb_mProjToDevice);
#endif
#else
#if defined(SHD_NO_NEAR_CLIP)
        matrix viewProj = mul(cb_mViewInstance[InstanceID], cb_mNoNearProj);
#elif defined(SHD_NO_FAR_CLIP)
        matrix viewProj = mul(cb_mViewInstance[InstanceID], cb_mNoFarProj);
#else
        matrix viewProj = mul(cb_mViewInstance[InstanceID], cb_mProjToDevice);
#endif
#endif

        output.fFogDistance = input[0].fFogDistance;
        output.mAlt = input[0].position[0].y;

        // Bottom left
        output.position = mul(input[0].position[0], viewProj);
        output.diffuse = input[0].diffuse[0];
        #if !defined(SHD_VIEW_CUBEMAP)
        ComputeFarAndNearFade(output.position, output.diffuse);
        #endif
        output.uv.x = lowerleft.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Bottom right
        output.position = mul(input[0].position[2], viewProj);
        output.diffuse = input[0].diffuse[2];
        #if !defined(SHD_VIEW_CUBEMAP)
        ComputeFarAndNearFade(output.position, output.diffuse);
        #endif
        output.uv.x = lowerleft.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Top Left
        output.position = mul(input[0].position[1], viewProj);
        output.diffuse = input[0].diffuse[1];
        #if !defined(SHD_VIEW_CUBEMAP)
        ComputeFarAndNearFade(output.position, output.diffuse);
        #endif
        output.uv.x = upperright.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        // Top right
        output.position = mul(input[0].position[3], viewProj);
        output.diffuse = input[0].diffuse[3];
        #if !defined(SHD_VIEW_CUBEMAP)
        ComputeFarAndNearFade(output.position, output.diffuse);
        #endif
        output.uv.x = upperright.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        SpriteStream.RestartStrip();

    #else
        output.fFogDistance = input[0].fFogDistance;
        output.mAlt = input[0].mAlt.y;

        // Bottom left
        output.position = input[0].position[0];
        output.diffuse = input[0].diffuse[0];
        output.uv.x = lowerleft.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Bottom right
        output.position = input[0].position[2];
        output.diffuse = input[0].diffuse[2];
        output.uv.x = lowerleft.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = 1;
        SpriteStream.Append(output);

        // Top Left
        output.position = input[0].position[1];
        output.diffuse = input[0].diffuse[1];
        output.uv.x = upperright.x;
        output.uv.y = lowerleft.y;
        output.localUV.x = -1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        // Top right
        output.position = input[0].position[3];
        output.diffuse = input[0].diffuse[3];
        output.uv.x = upperright.x;
        output.uv.y = upperright.y;
        output.localUV.x = 1;
        output.localUV.y = -1;
        SpriteStream.Append(output);

        SpriteStream.RestartStrip();
    #endif
}

#if defined(SHD_VIEW_SHADOW)
float2 PS(GS_OUTPUT In): SV_TARGET
{
    float4 cColor = txBase.Sample( samWrap, In.uv );
    return float2( 1.0f-cColor.a*saturate(SetPSS1) ,  In.z);
}
#else

float4 PS(
#if defined(SHD_GS_INSTANCING)
    GS_OUTPUT In
#else
    PS_INPUT In
#endif
) : SV_TARGET
{    

 float fAngY =  In.mAlt/(In.fFogDistance+1) ;
  float fAngYh =  (In.mAlt + 2*cb_Altitude )/(In.fFogDistance+1) ;
  float TempAngY1 = exp(-pow(abs( 4*fAngY), 3 )) * (1-exp(-pow(abs( 3*In.fFogDistance/10000 ), 2 )))  ;
  float TempExH1  = saturate( exp( -11*fAngYh )) ;
  float tempHYc =  1-saturate(exp(-11* abs( fAngYh   ))) ;
  float tempZv =  1-saturate(exp(-pow( abs(8* ( fAngYh-1  ) ),  3))) ;
     float fExp32 = saturate(exp(  SetVS3S* (In.fFogDistance - SetVS3D*0.9 )));
  float HAcompY = In.mAlt+ cb_Altitude +3100*pow(abs(In.fFogDistance/200000), 2 ) +1.1*aSetC9H*SetVS3*fExp32 ;
  float hCAltitudeY1 = HAcompY/10000 ;
  float fIntAltCorr1 = (1-exp(-pow(abs( 4 * hCAltitudeY1), 3.5)))*saturate(tanh( 2.2 *hCAltitudeY1))  ;
  float cfIntAltTR =  lerp(lerp(0.55, 1, fIntAltCorr1), 0.0, FACorE1) ;
//   float fIntAlt = pow(abs(saturate( 1*((In.mAlt + cb_Altitude )/10000) )), 1.2 ) ;  //     1-exp( -pow(abs( 3*((In.mAlt + cb_Altitude )/10000)), 2.8 ))                 
   float fIntAlt = saturate( tanh(1*((In.mAlt + cb_Altitude )/10000)) )    ;
   float fIntAlt2 = saturate( (In.mAlt + cb_Altitude )/10000  )    ;

  const float BLSu1  = 0.900  ;  // уровень ¤ркости в точке восхода/заката
  const float BposD1 = -0.27  ;  // позици¤ минимума до восхода/после заката. (начало нелинейного процесса нижн. ветки)
  const float BscD1  = 4.0    ;  // крутизна нарастани¤/падени¤ ¤ркости до восхода/после заката. (нижн. ветка)
  const float BposL1 = -0.40  ;  // позици¤ минимума линейного процесса до восхода/после заката.
  const float BLdSu1 = 0.12   ;  // уровень линейного процесса в точке восхода/заката
  const float BFIw1  = -22    ;  // ширина интерпол¤ции веток с центром в точке восхода/заката

  float FGBrSkyD1 =  saturate(  -(BLdSu1/BposL1)*(Sundy-BposL1)       //  линейный директионал
  +(BLSu1-BLdSu1)*pow( abs((Sundy-BposD1)/BposD1), BscD1 )*step(0, (Sundy-BposD1)))  ; // нижн¤¤ ветка
  float GBrSky1 = saturate( FGBrSkyD1) ; //
  float GBrSky_1 = saturate(1-GBrSky1)  ; //
  float GBrSkyd = saturate(1.2*(cb_mCloudDirectional.r+cb_mCloudDirectional.g +cb_mCloudDirectional.b)/3) ;

    float4  Rdiffuse = float4(In.diffuse.r, In.diffuse.r, In.diffuse.r, In.diffuse.a ) ;
    float4 RCcColor = txBase.Sample(samWrap, In.uv);
    float CanallsRGB = 1 - SetPS00*saturate(1-RCcColor.r)  ;  // RCcColor.r   
    float4 ColorM0 = Rdiffuse*float4(CanallsRGB, CanallsRGB, CanallsRGB, RCcColor.a )  ;  // RCcColor.r

    const float fExp = saturate(exp(-In.fFogDistance * In.fFogDistance * 0.00000000077));
    float fDistP1 =  pow(abs(1-1*saturate(In.fFogDistance/(1000000* 0.1) )), 5 ) ;
    float fDistP1_1 = 1-fDistP1  ;  float fDistP1_2 = 1-fDistP1*POstProcessS2*(1-fAexp83)  ;
    float fDistP1_3 = 1-fDistP1*POstProcessS2* fAexp83  ;

    float LbSc  = 0.7 ;  float Scfdb  = 2 ;  
    float offsSdy = 0.3 ;  float Scfd = 5 ;  float fxoffsSdy = Sundy-offsSdy ;
    float ProcessRGBc =  saturate( LbSc*pow(abs(Sundy-1), Scfdb) +(1-LbSc)* step(0, -fxoffsSdy )*pow(abs(fxoffsSdy/offsSdy), Scfd )  ) ;
    float Process_RGBc =  1-ProcessRGBc ;
    float addSunGc =  SetPS10*In.diffuse.b*RCcColor.b*tempHYc*VisSunOn  ;
    float3 ColorM1  = SetPS02*pow(abs(ColorM0.rgb), SetPS01  ) + addSunGc  ;
    float colorFErgb = (ColorM1.r+ColorM1.g+ColorM1.b)/3 ;
     float alfaFG1 = saturate(pow(abs(   1.0* ( 1-ColorM0.a)), 3 ))   ;
    float colorInv = saturate(1-2*RCcColor.b) ;

// ѕредварительна¤ настройка ¤ркости и гаммы перед теневым фильтром    //  lerp(SetPS04s, SetPS04z, (0.7*ProcessDE1 + 0.3*saturate(Sundy)) )
    float FPBrC    = cSetPS04*SetPS05 ; // некомпенсированна¤  настройка предварительной ¤ркости под теневой фильтр
// Ќастройка компенсации падени¤ ¤ркости на выходе теневого и цветового фильтра дл¤ общей стабилизации ¤ркости на выходе
    float blBrC    = clamp(FPBrC/SetPS06, 0.0001, 100000)  ; // результирующий коэффициент ¤ркости под теневой фильтр
    float LCompFBr = SetPS07  ; // уровень компенсации падени¤ ¤ркости на выходе фильтра // =0 - компенсаци¤ ¤ркости полностью отсутствует. =1 - полна¤ компенсаци¤.
    float LSpFBr   = SetPS08  ; // крутизна изменени¤ компенсации ¤ркости на выходе фильтра
    float TLBrmin  = SetPS09  ; // нижний порог ограничени¤ компенсации ¤ркости на выходе фильтра

    float K_blBrCFin = pow(abs(lerp( 1,  pow(abs(blBrC), LSpFBr )+TLBrmin, LCompFBr )), 3 ) ;
    float3 ColorM2   =  FPBrC*pow(abs(ColorM0.rgb), SetPS03  ) + addSunGc     ;  //  0*clamp(  pow(abs( 1*(colorFErgb-fA0)), 3) , 0, 10 )   +

    float3 ColorMcf   =   ColorM2*(1+ 0*In.diffuse.g )  ; //    

    float fCFint1 = 0.99*exp(-pow(abs( 0.70 *colorFErgb), 3  )) ; // интерпол¤тор ¤ркостного градиента тела обл.
    float fCFint2_1 =    clamp((colorFErgb- 0.5 )* 1,  0, 10  )  ; //1 - exp(-pow(abs( 3 *colorFErgb), 3  )) +  step(0, colorFErgb-0.4 )*pow(abs((colorFErgb- 0.4 )* 1  ), 2 )
    float fCFintR = exp(-pow(abs( 0.8 *colorFErgb), 3  )) ; // интерпол¤тор ¤ркостного градиента R.

 

   float fCGint1 =    0*PReProcessEG1*clamp((colorFErgb- 2*0.50 )* (0.5+1),  0, 10  )  ; // интерпол¤тор ¤ркостного градиента тела обл.
    float fDistP1eff = fDistP1_1*SetPS21 ;

    float infIntGB = lerp(lerp(lerp( 0,  SetPS22,  fDistP1eff ), 1, ProcessRGBc ), 1, SetPS14 ) ;
    float infIntGB_A = infIntGB*lerp(SetPS18, SetPS19, PReProcessEG2 )*lerp(SetPS20, 1, POstProcessS3) ;
    float infIntGB_B = infIntGB ;
//  онечные цветовые точки цветовой интерпол¤ции
    float FintCAg = SetPS15g+SetPS16g*PReProcess_E2*PReProcessEG2     ; // g - компонент дл¤ вершин.
    float FintCAb = SetPS15b    ; // b - компонент дл¤ вершин.
    float FintCBg = SetPS17g    ; // g - компонент дл¤ нижней части .
    float FintCBb = SetPS17b    ; // b - компонент дл¤ нижней части .
    float SatGnC =   POstProcessB0  ; // реверс интерпол¤ции после захода              

    float fIntAbovG = lerp( 1, lerp(1, FintCAg, RIntGc(infIntGB_A) ),  SatGnC  ) ; //  RIntGc(infIntGB_A)
    float fIntAbovB = lerp( 1, lerp(1, FintCAb,        infIntGB_A  ),  SatGnC  ) ; //  
    float fIntButtG = lerp( 1, lerp(1, FintCBg, RIntGc(infIntGB_B) ),  SatGnC  ) ; //  RIntGc(infIntGB_B)
    float fIntButtB = lerp( 1, lerp(1, FintCBb,        infIntGB_B  ),  SatGnC  ) ; //  
    float CorrGc = 1- 0.15*POstProcessD1*ProcessDT_1 ;
     ColorMcf.r *= lerp(1, 1, fIntAlt )*lerp( 1,  SetPS22r,  fDistP1eff )/(1+ 0.3*fCGint1)  ;
     ColorMcf.g *= lerp(fIntButtG, fIntAbovG, fIntAlt )*lerp(1, SetPS22g, fDistP1eff )*CorrGc/(1+ 0.35*fCGint1)   ;  //    
     ColorMcf.b *= lerp(1, 1, fIntAlt )*lerp(fIntButtB, 1*fIntAbovB, fIntAlt )*lerp(1, SetPS22b, fDistP1eff )/(1+ 0.65*fCGint1)     ;  //  

    float GsatBr = lerp( SetPS42, lerp(SetPS40, SetPS41,  POstProcessS3*PReProcess_E2), fIntAlt)  ;
    float addsatBr = FProcessF( SetPS47a, SetPS47e, SetPS47s )  ; // коэффициент добавочной насыщенности самых ¤рких участков
    ColorMcf  = lerp(dot(ColorMcf, float3(0.299f, 0.587f, 0.114f )), ColorMcf,   GsatBr*(1+ addsatBr*fCFint2_1) ) ;  //  tempZv* lerp(1, 0.5*pow(abs(colorFErgb ), 0.8 ), 0.9 )
    ColorMcf  = lerp(dot(ColorMcf, float3(0.299f, 0.587f, 0.114f )), ColorMcf,   POstProcessS1*FProcessF( SetPS48a, SetPS48e, SetPS48s ) ) ;
    ColorMcf  = lerp(ColorMcf,  ColorMcf*float3((1- 0.8*alfaFG1), (1+ 0.3*alfaFG1), (1+ 0.8*alfaFG1) ), SetPS49 ) *(1+0.0*fIntAlt2)   ;   /// *lerp( 1, float3( 1, 0.50 , 0.50 ), 0.7*(1-fExp)*PReProcessE2 )

   float CompBrRGB = ((ColorM2.r-ColorMcf.r)+(ColorM2.g-ColorMcf.g)+(ColorM2.b-ColorMcf.b))/3 ;
   float3 ColorMF   = ColorMcf*(1 + 0.0*CompBrRGB+ 0.0* (1-fExp)*PReProcessE2)*(1+ 0.2*POstProcess_S1) ; //         ColorM2            ;

    float fLevL = cSetPS55*SetPS54  ;  // ќсновной абсолютный уровень фильтра
//   омпенсаци¤ ¤ркости дл¤ стабилизации ¤ркости теневых участков при регулировке уровн¤ теневого фильтра
    float CompBrF = cSetPS56   ;  // ”ровень компенсации ¤ркости цвета на выходе при регулировке теневого фильтра
    float sFlev = SetPS59  ;  // ќсновна¤ крутизна фильтра
    float andSunLft0 = 1+ 0.5*ProcessSn1*lerp(1, ProcessDE5, 1 )*In.diffuse.g  ; //
    float andSunLft1 = lerp(andSunLft0, 1, 0 ) ;
//  общий коеффициент порога нижнего(теневого) уровн¤ ограничени¤.(сглаживание и обрезание детализации) ‘инальный компонент.
    float gLovTrDet = fLevL*1.7*(1+0.1*TempExH1)*andSunLft0*lerp(0.9, 1-0.5*POstProcess_D1*POstProcessB1, TempAngY1) ;   

// покомпонентные пороги теневого ограничени¤ детализации.
    float CLovTrR = SetPS57r ; float CLovTrG = SetPS57g ; float CLovTrB = SetPS57b  ; float3 CLovTrRGB = float3(CLovTrR, CLovTrG, CLovTrB) ;
    CLovTrRGB = lerp(dot(CLovTrRGB, float3(0.2126f, 0.7152f, 0.0722f)), CLovTrRGB, SetPS58 ) ;
// покомпонентные коэффициенты финальной коррекци¤ переходных порогов
    float corrTrR = SetPS61r  ; float corrTrG = SetPS61g  ; float corrTrB = SetPS61b  ;
    float LovTrDetR = CLovTrRGB.r*gLovTrDet ; float LovTrDetG = CLovTrRGB.g*gLovTrDet ; float LovTrDetB = CLovTrRGB.b*gLovTrDet ;
    ColorMF.r = lerp( ColorMF.r, LovTrDetR, saturate(0.5+0.5*tanh( -sFlev* ( ColorMF.r-LovTrDetR*corrTrR )  )) ) ; //  1+0.*0.5
    ColorMF.g = lerp( ColorMF.g, LovTrDetG, saturate(0.5+0.5*tanh( -sFlev* ( ColorMF.g-LovTrDetG*corrTrG )  )) ) ; //  1+0.5*0.1
    ColorMF.b = lerp( ColorMF.b, LovTrDetB, saturate(0.5+0.5*tanh( -sFlev* ( ColorMF.b-LovTrDetB*corrTrB )  )) ) ;

    ColorMF  = 1*lerp(dot(ColorMF, float3(0.2126f, 0.7152f, 0.0722f)), ColorMF, SetPS79 ) ;

//    float3 ColorM3 =   1.0*(1+ 0*In.diffuse.g)*lerp( ColorM1 , ColorM2,  0 ) ;

       float4  cColor  ;  cColor.a = ColorM0.a ;
    cColor.rgb = ColorMF*lerp( 1,  CompBrF,   fLevL)/K_blBrCFin  ;   //                                
    cColor.rgb =  lerp(  cColor.rgb, 0.07*float3(0.65, 0.85, 1), 0.0 )*(1+ 0.10*In.diffuse.g*PReProcessEG  )/andSunLft1   ; // ProcessSn1*ProcessDE5*

    cColor.rgb *= lerp(float3(SetPS82r, SetPS82g, SetPS82b), float3(1, 1, 1), lerp(1, lerp( 0,saturate(1-SetPS81), fDistP1), SetPS80) ) ;  //  подсинивание

     cColor.rgb = pow(abs(cColor.rgb), 1+SetPS85*In.diffuse.b )*(1+SetPS86*POstProcessS2*In.diffuse.b)
                *lerp(SetPS91, SetPS90, GBrSky1) *lerp(1.0, 0.38, TempAngY1*(1-In.diffuse.b)*POstProcess_D1*POstProcessB1    )         ; //   
    cColor.rgb  = 1.1*cSetPS93*lerp(dot(cColor.rgb, float3(0.2126f, 0.7152f, 0.0722f)), cColor.rgb, SetPS94 ) ;

    cColor.a *= lerp( 1.05, 0.80, fIntAlt)      ;  // *float3(1.3, 0.83, 1 )
    cColor.a = lerp( SetPS98, SetPS97, fDistP1 )*pow(abs(cColor.a), SetPS99 )       ;

    // Apply IR if active
    #if defined(SHD_IR_ACTIVE)
        cColor = ApplyIr(cColor);
        cColor = FogIR(cColor, In.fFogDistance);

#if defined(SHD_IR_BLACK_HOT)
        cColor.rgb = 1.0f - cColor.rgb;
#endif

        return cColor;
    #endif //SHD_IR_ACTIVE

    //Soft edges.
    #if defined(SHD_CLOUD_FADE_AT_Z)
    #endif

    #if !defined(SHD_NO_FOG) && !defined(SHD_VIEW_CUBEMAP)
        //Compute fog contribution.
        #if defined(SHD_VOLUMETRIC_FOG)
            cColor = VolumetricFogPS( In.mAlt, cColor, In.fFogDistance / 2.0, cb_mFogDensity, cb_mFogColor.xyz);
        #else
            cColor = float4( FogPS( cColor.xyz, In.fFogDistance / 2.0, cb_mFogDensity, cb_mFogColor.xyz ), cColor.a );
        #endif //SHD_VOLUMETRIC_FOG
    #endif //!SHD_NO_FOG

    DEBUG_MARK(cColor)

    return cColor;
}
#endif

 

Edited February 5, 2022 by Rogen
clarity

[timest 472]

On 1/9/2022 at 11:21 PM, Rogen said:

How about the look of these dynamically lit clouds in my P3D v4.5.

Wow, amazing shot @Rogen. Definitely REX textures used here... I would know 😉 

[d.tsakiris 418]

Looks great. Does someone have this mod running successfully in 5.3 HF2?

[LGKR 36]

I could not make it work in p3d 5.3 HF2.

The clouds seem to be deleted. Reinstall of REX clouds does not fix it.  Reverted to original cloud.fx.

[Rogen 1,087]

On 7/19/2022 at 9:45 PM, LGKR said:

I could not make it work in p3d 5.3 HF2.

The clouds seem to be deleted. Reinstall of REX clouds does not fix it.  Reverted to original cloud.fx.

Yeah, shaders are very version specific and the showcased one happens to be written for 4.5.13

I did read there was a v5 version in the making, don't know what happened with it though.

Cheers