API tools faq
paste
emd22

Untitled

emd22
Nov 27th, 2025
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Godot GLSL 8.72 KB | None | 0 0
raw download clone embed print report
  1.  
  2. void CalculateEmissiveContribution(inout SurfaceProperties surfaceInfo)
  3. {
  4. #if EMISSIVE || EMISSIVE_ADDITIVE
  5.     surfaceInfo.surface_emissiveIntensity = emissiveMultiplier *
  6.                                             surfaceInfo.surface_diffuseColor.a *
  7.                                             gEmissiveScale;
  8.  
  9.     #if EMISSIVE_NIGHTONLY
  10.         surfaceInfo.surface_emissiveIntensity *= gDayNightEffects;
  11.     #endif
  12. #else
  13.     surfaceInfo.surface_emissiveIntensity = 0.0;
  14. #endif
  15. }
  16.  
  17. // ----------------------------------------------------------------------------------------------- //
  18. #define MIN_NUM_OF_PXM_STEPS 8
  19. #define MAX_NUM_OF_PXM_STEPS 30
  20.  
  21. SurfaceProperties GetSurfaceProperties( float4          IN_baseColor,
  22. #if PALETTE_TINT
  23.                                         float4          IN_baseColorTint,
  24. #endif
  25. #if DIFFUSE_TEXTURE
  26.                                         float2          IN_diffuseTexCoord,
  27.                                         sampler2D       IN_diffuseSampler,
  28. #endif
  29. #if DIFFUSE2 || DIFFUSE3 || OVERLAY_DIFFUSE2
  30.                                         float2          IN_diffuseTexCoord2,
  31.                                         sampler2D       IN_diffuseSampler2,
  32. #endif
  33. #if OVERLAY_DIFFUSE2 && OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
  34.                                         float           IN_diffuse2Alpha,
  35. #endif
  36. #if SPEC_MAP
  37.                                         float2          IN_specularTexCoord,
  38.                                         sampler2D       IN_specularSampler,
  39. #endif  // SPEC_MAP
  40. #if REFLECT
  41.                                         float3          IN_worldEyePos,
  42.                                         REFLECT_SAMPLER IN_environmentSampler,
  43.     #if REFLECT_MIRROR
  44.                                         float2          IN_mirrorTexCoord,
  45.                                         float4          IN_screenPos,
  46.     #endif // REFLECT_MIRROR
  47. #endif // REFLECT
  48. #if NORMAL_MAP
  49.                                         float2          IN_bumpTexCoord,
  50.                                         sampler2D       IN_bumpSampler,
  51.                                         float3          IN_worldTangent,
  52.                                         float3          IN_worldBinormal,
  53.     #if PARALLAX || PARALLAX_MAP_V2
  54.         #if PARALLAX
  55.                                         float3          IN_tanEyePos,
  56.         #endif
  57.         #if PARALLAX_MAP_V2
  58.                                         float3          IN_worldEyePosPOM,
  59.                                         sampler2D       IN_heightSampler,
  60.             #if EDGE_WEIGHT
  61.                                         float2          IN_edgeWeight,
  62.             #endif // EDGE_WEIGHT
  63.         #endif // PARALLAX_MAP_V2
  64.     #endif //  PARALLAX || PARALLAX_MAP_V2
  65. #endif  // NORMAL_MAP
  66. #if NORMAL_MAP2
  67.                                         float2          IN_bumpTexCoord2,
  68.                                         sampler2D       IN_bumpSampler2,
  69.                                         float3          IN_worldTangent2,
  70.                                         float3          IN_worldBinormal2,
  71. #endif  // NORMAL_MAP2
  72. #if DIRT_NORMALMAP
  73.                                         float3          IN_dirtBumpUV,      // xy = UV, z = dirtLevel
  74.                                         sampler2D       IN_dirtBumpSampler,
  75. #endif//DIRT_NORMALMAP...
  76. #if DETAIL_UV
  77.                                         float2          IN_detailUV,
  78. #endif //DETAIL_UV...
  79.                                         float3          IN_worldNormal
  80.                         )
  81. {
  82.     SurfaceProperties OUT = (SurfaceProperties)0;
  83.  
  84.     OUT.surface_baseColor       = IN_baseColor;
  85.  
  86. #if PALETTE_TINT
  87.     OUT.surface_baseColorTint   = IN_baseColorTint;
  88. #endif
  89.  
  90. #if DIFFUSE2 || DIFFUSE3 || OVERLAY_DIFFUSE2
  91.     OUT.surface_overlayColor = tex2D(IN_diffuseSampler2, IN_diffuseTexCoord2); 
  92. #if OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
  93.     OUT.surface_overlayColor.a = IN_diffuse2Alpha;
  94. #endif // OVERLAY_DIFFUSE2_SEPARATE_ALPHA_SOURCE
  95. #endif  // DIFFUSE2
  96.  
  97. #if PARALLAX
  98.     float2 outTexCoord;
  99.     float3 parallaxPackedNormalHeight = CalculateParallax(
  100.         IN_tanEyePos,
  101.         tex2D_NormalHeightMap(IN_bumpSampler, IN_bumpTexCoord.xy),
  102.         IN_diffuseTexCoord,
  103.         IN_bumpTexCoord,
  104.         IN_bumpSampler,
  105.         outTexCoord).xyz;
  106.     IN_diffuseTexCoord = outTexCoord;
  107. #endif // NORMAL_MAP
  108.  
  109. #if PARALLAX_MAP_V2 && __SHADERMODEL >= 40
  110. #if EDGE_WEIGHT
  111.     float edgeWeight = 1.0f - clamp(IN_edgeWeight.x, 0.0f, 1.0f);
  112.     float zLimit = clamp(1.0f - IN_edgeWeight.y, 0.1f, 1.0f);
  113. #else
  114.     float edgeWeight = 1.0f;
  115.     float zLimit = 0.1f;
  116. #endif
  117.  
  118.     if(POMDisable == 0)
  119.     {
  120.         float3 tanEyePos;
  121.  
  122.         tanEyePos.x = dot(IN_worldTangent.xyz, IN_worldEyePosPOM.xyz);
  123.         tanEyePos.y = dot(IN_worldBinormal.xyz, IN_worldEyePosPOM.xyz);
  124.         tanEyePos.z = dot(IN_worldNormal.xyz,   IN_worldEyePosPOM.xyz);
  125.  
  126.         tanEyePos = normalize(tanEyePos);
  127.         float clampedZ = max(zLimit, tanEyePos.z);
  128.        
  129.         float VdotN = abs(dot(normalize(IN_worldEyePosPOM.xyz), normalize(IN_worldNormal.xyz)));
  130.         float numberOfSteps = lerp(POMMaxSteps, POMMinSteps, VdotN);
  131.  
  132.         float globalScale = globalHeightScale * edgeWeight * saturate(numberOfSteps - 1.0f) * saturate(VdotN / POMVDotNBlendFactor);
  133.  
  134.         float2 maxParallaxOffset = (-tanEyePos.xy / clampedZ) * heightScale * globalScale;
  135.         float2 heightBiasOffset = (tanEyePos.xy / clampedZ) * heightBias * globalScale;
  136.  
  137.         float height = TraceHeight(IN_heightSampler, IN_diffuseTexCoord, maxParallaxOffset, heightBiasOffset, numberOfSteps).r;
  138.         float2 textCoordOffset = heightBiasOffset + (maxParallaxOffset * (1.0f - height));
  139.  
  140.         IN_diffuseTexCoord += textCoordOffset;
  141.         IN_bumpTexCoord += textCoordOffset;
  142. #if SPEC_MAP
  143.         IN_specularTexCoord += textCoordOffset;
  144. #endif // SPEC_MAP 
  145.     }
  146. #endif // PARALLAX_MAP_V2 && __SHADERMODEL >= 40
  147.  
  148.     #if DIFFUSE_TEXTURE
  149.         float4 diffuseColor = tex2D(IN_diffuseSampler, IN_diffuseTexCoord);
  150.     #else
  151.         float4 diffuseColor = float4(1.0, 1.0, 1.0, 1.0);
  152.     #endif
  153.     OUT.surface_diffuseColor = calculateDiffuseColor(diffuseColor);
  154.    
  155. #ifdef USE_DETAIL_MAP
  156.     float detailInten=1.f;
  157.     #if DETAIL_USE_SPEC_ALPHA_AS_CONTROL && SPECULAR && SPEC_MAP   
  158.         detailInten = tex2D(IN_specularSampler, IN_specularTexCoord.xy).w;
  159.     #endif
  160.  
  161.     #if DETAIL_UV
  162.         float2 detailUV = IN_detailUV.xy;
  163.     #elif DIRT_NORMALMAP
  164.         float2 detailUV = IN_dirtBumpUV.xy;
  165.     #else
  166.         float2 detailUV = IN_diffuseTexCoord.xy;
  167.     #endif
  168.     float3 detailBumpAndIntensity = GetDetailBumpAndIntensity(  detailUV,  detailInten);
  169.  
  170.     OUT.surface_diffuseColor  *= detailBumpAndIntensity.z;
  171. #endif
  172.  
  173. #if WRINKLE_MAP
  174.     OUT.surface_worldNormal.xyz = CalculateWrinkleNormal(
  175.         IN_bumpSampler,
  176.         IN_bumpTexCoord.xy,
  177.         IN_worldTangent,
  178.         IN_worldBinormal,
  179.         IN_worldNormal);
  180. #else
  181.     #if NORMAL_MAP
  182.         #if PARALLAX
  183.             float3 packedNormal = float3(0.0, 0.0, 0.0);
  184.         #else
  185.             float3 packedNormal = tex2D_NormalMap(IN_bumpSampler, IN_bumpTexCoord.xy).xyz;
  186.         #endif
  187.         float3 packedNormalHeight = CalculatePackedNormal(
  188.             packedNormal,
  189.             #if PARALLAX
  190.                 parallaxPackedNormalHeight,
  191.             #endif
  192.             #if DIRT_NORMALMAP
  193.                 IN_dirtBumpSampler,
  194.                 IN_dirtBumpUV.xyz,
  195.             #endif
  196.             IN_bumpTexCoord.xy);
  197.  
  198.             #ifdef USE_DETAIL_MAP
  199.                 packedNormalHeight.xy += detailBumpAndIntensity.xy;
  200.             #endif
  201.  
  202.             OUT.surface_worldNormal.xyz = CalculateWorldNormal(
  203.                 packedNormalHeight.xy,
  204.                 bumpiness,
  205.                 IN_worldTangent,
  206.                 IN_worldBinormal,
  207.                 IN_worldNormal);
  208.     #else
  209.         //should be normalized as the normal is interpolated from vertex normals
  210.         OUT.surface_worldNormal.xyz = normalize(IN_worldNormal.xyz);
  211.     #endif
  212. #endif
  213.  
  214. #ifdef DECAL_USE_NORMAL_MAP_ALPHA
  215.     OUT.surface_worldNormal.a = packedNormalHeight.z;
  216. #endif
  217.  
  218. #if NORMAL_MAP2
  219.     float3 packedNormalHeight2 = tex2D_NormalMap(IN_bumpSampler2, IN_bumpTexCoord2.xy).xyz;
  220.     OUT.surface_worldNormal2.xyz = CalculateWorldNormal(packedNormalHeight2.xy, bumpiness, IN_worldTangent2, IN_worldBinormal2, IN_worldNormal);
  221. #endif
  222.  
  223. #if SPECULAR
  224.     CalculateSpecularContribution(
  225.         OUT,
  226.         #if SPEC_MAP
  227.             IN_specularSampler,
  228.             IN_specularTexCoord.xy,
  229.         #endif
  230.         IN_baseColor,
  231.         OUT.surface_worldNormal);
  232.  
  233.     #ifdef USE_DETAIL_MAP
  234.         OUT.surface_specularIntensity *=detailBumpAndIntensity.z;
  235.     #endif
  236.  
  237. #endif
  238.  
  239. #if REFLECT
  240.     float3 surfaceToEyeDir = normalize(IN_worldEyePos);
  241.     CalculateReflection(
  242.         OUT,
  243.         IN_environmentSampler,
  244.         #if REFLECT_MIRROR
  245.             IN_screenPos,
  246.         #endif
  247.         #if defined(USE_MIRROR_CRACK_MAP)
  248.             IN_mirrorTexCoord,
  249.         #endif
  250.         #if SPECULAR
  251.             OUT.surface_specularExponent,
  252.         #endif
  253.         surfaceToEyeDir,
  254.         OUT.surface_worldNormal);
  255. #endif
  256.  
  257. #if PARALLAX
  258.     // parallax only: if BumpMap.xy is (0,0), then we want no lighting:
  259.     const float threshold = 0.002f; // 0.00001f
  260.     float parallaxLightMask = (dot(packedNormalHeight.xy, packedNormalHeight.xy) >= threshold);
  261.  
  262.     OUT.surface_diffuseColor.rgb    *= parallaxLightMask;
  263.     OUT.surface_baseColor.rgb       *= parallaxLightMask;
  264.     OUT.surface_specularIntensity   *= parallaxLightMask;
  265. #endif //PARALLAX...
  266.  
  267. #ifdef COLORIZE
  268.     OUT.surface_diffuseColor.rgba*=colorize;
  269. #endif
  270.  
  271. #if SELF_SHADOW
  272.     OUT.surface_selfShadow = 1.0f;
  273. #endif
  274.  
  275. #if PARALLAX_MAP_V2 && __SHADERMODEL >= 40
  276.     float3 tanLightDirection;
  277.  
  278.     tanLightDirection.x = dot(IN_worldTangent.xyz, gDirectionalLight.xyz);
  279.     tanLightDirection.y = dot(IN_worldBinormal.xyz, gDirectionalLight.xyz);
  280.     tanLightDirection.z = dot(IN_worldNormal.xyz, gDirectionalLight.xyz);
  281.     float shadowAmount = TraceSelfShadow(IN_diffuseTexCoord, IN_heightSampler, tanLightDirection, 1.0f - IN_edgeWeight, heightScale * globalHeightScale);
  282.     OUT.surface_selfShadow = (1.0f - shadowAmount * parallaxSelfShadowAmount);
  283.  
  284. #if EDGE_WEIGHT
  285.     if(POMEdgeVisualiser)
  286.     {
  287.         OUT.surface_diffuseColor.r = clamp(IN_edgeWeight.x, 0.0f, 1.0f);
  288.         OUT.surface_diffuseColor.g = 1.0f - clamp(IN_edgeWeight.y, 0.0f, 1.0f);
  289.         OUT.surface_diffuseColor.b = 0.0f;
  290.     }
  291. #endif
  292. #endif
  293.  
  294. #if USE_SLOPE
  295.     OUT.slope = CalcSlope(IN_worldNormal.z);
  296. #endif
  297.  
  298.     CalculateEmissiveContribution(OUT);
  299.  
  300.     return OUT;
  301. }
  302.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!