883 lines
27 KiB
HLSL
883 lines
27 KiB
HLSL
#ifndef PI
|
||
#define PI 3.14159265
|
||
#endif
|
||
|
||
#ifndef TWO_PI
|
||
#define TWO_PI 6.28318530
|
||
#endif
|
||
|
||
#ifndef INV_PI
|
||
#define INV_PI 0.31830989
|
||
#endif
|
||
|
||
uniform Texture3D _Noise;
|
||
SamplerState sampler_Noise;
|
||
uniform Texture3D _DetailNoise;
|
||
SamplerState sampler_DetailNoise;
|
||
uniform Texture2D _WeatherMap;
|
||
SamplerState sampler_WeatherMap;
|
||
uniform Texture2D _CurlNoise;
|
||
SamplerState sampler_CurlNoise;
|
||
|
||
uniform sampler2D _BottomsOffsetNoise;
|
||
uniform sampler2D _BlueNoise;
|
||
|
||
float4 _BlueNoise_TexelSize;
|
||
float3 _WorldOffset;
|
||
|
||
uniform float4x4 _InverseProjection;
|
||
uniform float4x4 _InverseRotation;
|
||
uniform float4x4 _InverseProjectionRight;
|
||
uniform float4x4 _InverseRotationRight;
|
||
|
||
float4x4 _LeftWorldFromView;
|
||
float4x4 _RightWorldFromView;
|
||
float4x4 _LeftViewFromScreen;
|
||
float4x4 _RightViewFromScreen;
|
||
|
||
uniform float4 _CloudsParameter;
|
||
uniform float4 _CloudsParameter2;
|
||
|
||
uniform float4 _Steps;
|
||
uniform float4 _CloudsLighting;
|
||
uniform float4 _CloudsLighting2;
|
||
uniform float4 _CloudsLightingExtended;
|
||
uniform float4 _CloudsLightingExtended2;
|
||
|
||
uniform float4 _CloudsMultiScattering;
|
||
uniform float4 _CloudsMultiScattering2;
|
||
|
||
uniform float4 _CloudsErosionIntensity; //x = Base, y = Detail
|
||
uniform float4 _CloudsNoiseSettings; //x = Base, y = Detail
|
||
|
||
uniform float4 _CloudsShape1;
|
||
uniform float4 _CloudsShape2;
|
||
|
||
uniform float4 _CloudDensityScale;
|
||
uniform float4 _CloudsCoverageSettings; //x = _GlobalCoverage, y = Bottom Coverage Mod, z = Top coverage mod, w = Clouds Up Morph Intensity
|
||
uniform float _GlobalCoverage;
|
||
uniform float4 _CloudsAnimation;
|
||
uniform float4 _CloudsWindDirection;
|
||
|
||
uniform float3 _LightDir;
|
||
uniform float _stepsInDepth;
|
||
uniform float _LODDistance;
|
||
uniform float3 _CameraPosition;
|
||
uniform float4 _Resolution;
|
||
uniform float4 _Randomness;
|
||
uniform float _EnviroDepthTest;
|
||
uniform float _SolarTime;
|
||
////
|
||
const float env_inf = 1e10;
|
||
|
||
struct RaymarchParameters
|
||
{
|
||
//Lighting
|
||
float scatteringCoef;
|
||
float silverLiningIntensity;
|
||
float silverLiningSpread;
|
||
float edgeHighlightStrength;
|
||
float directIndirectBalance;
|
||
float exposure;
|
||
float attenuation;
|
||
float lightStep;
|
||
float lightAbsorb;
|
||
float multiScatterStrength;
|
||
float multiScatterFalloff;
|
||
float ambientFloor;
|
||
|
||
//Height
|
||
float4 cloudsParameter;
|
||
|
||
//Density
|
||
float density;
|
||
float densitySmoothness;
|
||
|
||
//Erosion
|
||
float baseErosion;
|
||
float detailErosion;
|
||
|
||
int minSteps, maxSteps;
|
||
|
||
float baseNoiseUV;
|
||
float detailNoiseUV;
|
||
|
||
float baseErosionIntensity;
|
||
float detailErosionIntensity;
|
||
|
||
float baseNoiseMultiplier;
|
||
float detailNoiseMultiplier;
|
||
|
||
float bottomShape;
|
||
float midShape;
|
||
float topShape;
|
||
float topLayer;
|
||
float rampShape;
|
||
float cloudTypeShaping;
|
||
};
|
||
|
||
void InitRaymarchParameters(inout RaymarchParameters parameters)
|
||
{
|
||
parameters.scatteringCoef = _CloudsLighting.x;
|
||
parameters.silverLiningIntensity = _CloudsLighting.y;
|
||
parameters.silverLiningSpread = _CloudsLighting.w;
|
||
|
||
parameters.multiScatterStrength = _CloudsMultiScattering.x;
|
||
parameters.multiScatterFalloff = _CloudsMultiScattering.y;
|
||
parameters.ambientFloor = _CloudsMultiScattering.z;
|
||
parameters.exposure = _CloudsMultiScattering.w;
|
||
|
||
parameters.directIndirectBalance = _CloudsLightingExtended.x;
|
||
parameters.attenuation = _CloudsLightingExtended.y;
|
||
parameters.lightStep = _CloudsLightingExtended.z;
|
||
parameters.lightAbsorb = _CloudsLightingExtended.w;
|
||
|
||
parameters.edgeHighlightStrength = _CloudsLighting.z;
|
||
|
||
parameters.cloudsParameter = _CloudsParameter;
|
||
|
||
parameters.density = _CloudDensityScale.x;
|
||
parameters.densitySmoothness = _CloudDensityScale.z;
|
||
|
||
parameters.baseErosion = _CloudsErosionIntensity.x;
|
||
parameters.detailErosion = _CloudsErosionIntensity.y;
|
||
|
||
parameters.baseNoiseMultiplier = _CloudsNoiseSettings.z;
|
||
parameters.detailNoiseMultiplier = _CloudsNoiseSettings.w;
|
||
|
||
parameters.minSteps = _Steps.x;
|
||
parameters.maxSteps = _Steps.y;
|
||
|
||
parameters.baseNoiseUV = _CloudsNoiseSettings.x;
|
||
parameters.detailNoiseUV = _CloudsNoiseSettings.y;
|
||
|
||
parameters.baseErosionIntensity = _CloudsErosionIntensity.x;
|
||
parameters.detailErosionIntensity = _CloudsErosionIntensity.y;
|
||
|
||
parameters.bottomShape = _CloudsShape1.x;
|
||
parameters.midShape = _CloudsShape1.y;
|
||
parameters.topShape = _CloudsShape1.z;
|
||
parameters.topLayer = _CloudsShape1.w;
|
||
|
||
parameters.rampShape = _CloudsCoverageSettings.w;
|
||
|
||
parameters.cloudTypeShaping = _CloudsCoverageSettings.z;
|
||
}
|
||
|
||
float HenryGreensteinNorm(float cosTheta, float g)
|
||
{
|
||
float g2 = g * g;
|
||
return (1.0 - g2) / (4.0 * PI * pow(1.0 + g2 - 2.0 * g * cosTheta, 1.5));
|
||
}
|
||
|
||
float RemapEnviro(float org_val, float org_min, float org_max, float new_min, float new_max)
|
||
{
|
||
return new_min + saturate(((org_val - org_min) / (org_max - org_min))*(new_max - new_min));
|
||
}
|
||
|
||
float4 GetWeather(float3 pos)
|
||
{
|
||
float2 uv = pos.xz * 0.0000025;
|
||
return _WeatherMap.SampleLevel(sampler_WeatherMap,uv, 0);
|
||
}
|
||
|
||
float GetSamplingHeight(float3 pos, float3 center, float4 parameters)
|
||
{
|
||
return (length(pos - center) - (parameters.w + parameters.x)) * parameters.z;
|
||
}
|
||
|
||
float3 ScreenSpaceDither(float2 vScreenPos, float lum)
|
||
{
|
||
float d = dot(float2(131.0, 312.0), vScreenPos.xy); //+ _Time TODO
|
||
float3 vDither = float3(d, d, d);
|
||
vDither.rgb = frac(vDither.rgb / float3(103.0, 71.0, 97.0)) - float3(0.5, 0.5, 0.5);
|
||
return (vDither.rgb / 15.0) * 1.0 * lum;
|
||
}
|
||
|
||
float GetRaymarchEndFromSceneDepth(float sceneDepth, float maxRange)
|
||
{
|
||
float raymarchEnd = 0.0f;
|
||
#if ENVIRO_DEPTH_BLENDING
|
||
if (sceneDepth >= 0.99f)
|
||
{
|
||
raymarchEnd = maxRange;
|
||
}
|
||
else
|
||
{
|
||
raymarchEnd = sceneDepth * _ProjectionParams.z;
|
||
}
|
||
#else
|
||
if(_EnviroDepthTest > 0 )
|
||
{
|
||
if (sceneDepth >= 0.99f)
|
||
{
|
||
raymarchEnd = maxRange;
|
||
}
|
||
else
|
||
{
|
||
raymarchEnd = sceneDepth * _ProjectionParams.z;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
raymarchEnd = maxRange;
|
||
}
|
||
#endif
|
||
return raymarchEnd;
|
||
}
|
||
|
||
float4 GetHeightGradient(float cloudType)
|
||
{
|
||
// x,y = bottom smoothstep, z,w = top smoothstep
|
||
const float4 CloudGradient1 = float4(0.0, 0.07, 0.08, 0.15); // Strato
|
||
const float4 CloudGradient2 = float4(0.0, 0.20, 0.42, 0.60); // Cumulus
|
||
const float4 CloudGradient3 = float4(0.0, 0.08, 0.75, 0.98); // Nimbus
|
||
|
||
float a = 1.0 - saturate(cloudType * 2.0); // 0→0.5 strato
|
||
float b = 1.0 - abs(cloudType - 0.5) * 2.0; // around 0.5 cumulus
|
||
float c = saturate(cloudType - 0.5) * 2.0; // 0.5→1 nimbus
|
||
|
||
return CloudGradient1 * a + CloudGradient2 * b + CloudGradient3 * c;
|
||
}
|
||
|
||
float GradientStep(float a, float4 g)
|
||
{
|
||
return smoothstep(g.x, g.y, a) - smoothstep(g.z, g.w, a);
|
||
}
|
||
|
||
// ---------- Final profile with varying bottom ----------
|
||
float CloudTypeShaping(float3 worldPos, float cloudType, RaymarchParameters p)
|
||
{
|
||
float _BottomVariation = 1000; // e.g. 500.0 m of random variation
|
||
float _NoiseScale = 0.000025; // e.g. 0.001 for slow world-scale noise
|
||
|
||
// noise-based base variation
|
||
float baseOffset = 0;
|
||
#if ENVIRO_VARIABLE_BOTTOM
|
||
baseOffset = tex2Dlod(_BottomsOffsetNoise, float4(worldPos.xz * _NoiseScale,0,0)).r * _BottomVariation;
|
||
#endif
|
||
float bottom = p.cloudsParameter.x + baseOffset;
|
||
float top = bottom + (p.cloudsParameter.y - p.cloudsParameter.x);
|
||
|
||
// normalized height
|
||
float h = saturate((worldPos.y - bottom) / (top - bottom));
|
||
|
||
// choose gradient band based on type
|
||
float4 gradient = GetHeightGradient(cloudType);
|
||
|
||
// final vertical profile
|
||
return GradientStep(h, gradient);
|
||
}
|
||
|
||
|
||
float CloudVerticalShaping(float heightNorm,
|
||
float bottomCtrl,
|
||
float midCtrl,
|
||
float topCtrl,
|
||
float ramp)
|
||
{
|
||
// --- Define segments ---
|
||
float2 bottomRange = float2(-0.1, 0.25);
|
||
float2 midRange = float2(0.20, 0.45);
|
||
float2 topRange = float2(0.40, 0.8); // top segment fades before 1.0
|
||
|
||
// --- Compute smooth ramps ---
|
||
float bottom = smoothstep(bottomRange.x, bottomRange.y, heightNorm) *
|
||
(1.0 - smoothstep(bottomRange.x + ramp, bottomRange.y + ramp, heightNorm));
|
||
|
||
float mid = smoothstep(midRange.x, midRange.y, heightNorm) *
|
||
(1.0 - smoothstep(midRange.x + ramp, midRange.y + ramp, heightNorm));
|
||
|
||
float top = smoothstep(topRange.x, topRange.y, heightNorm) *
|
||
(1.0 - smoothstep(topRange.x + ramp, topRange.y + ramp, heightNorm));
|
||
|
||
// --- Fade top influence out at absolute top ---
|
||
//top *= 1.0 - smoothstep(0.95, 1.0, heightNorm);
|
||
|
||
// --- Normalize weights so controls are balanced ---
|
||
float sum = bottom + mid + top + 1e-5;
|
||
bottom /= sum;
|
||
mid /= sum;
|
||
top /= sum;
|
||
|
||
// --- Apply coverage controls ---
|
||
float bias = bottomCtrl * bottom + midCtrl * mid + topCtrl * top;
|
||
|
||
// --- Map to envelope multiplier ---
|
||
// center at 1.0 = no change, limit to avoid full fill
|
||
float envelope = 1.0 + bias * 0.5; // adjust scale as needed
|
||
//envelope = envelope;
|
||
|
||
//Bottom Round
|
||
float edgeRound = 1.0 - exp(-heightNorm * 8.0);
|
||
envelope *= lerp(1.0, edgeRound, 0.9 * bottom);
|
||
|
||
|
||
|
||
// --- Subtle round-top modifier ---
|
||
float edgeRoundTop = 1.0 - exp(-(1.0 - heightNorm) * 8.0); // only affects highest ~0.8–1.0
|
||
envelope *= lerp(1.0, edgeRoundTop, 1.5 * top);
|
||
|
||
if(heightNorm > 0.90)
|
||
envelope = 0;
|
||
|
||
return envelope;
|
||
}
|
||
|
||
float CloudTopLayer(float heightNorm, float baseNoise, float topLayerAdd)
|
||
{
|
||
const float topMin = 0.90;
|
||
const float topMax = 0.94;
|
||
float verticalFalloff = smoothstep(topMin, topMax, heightNorm) - smoothstep(topMax, 1.0, heightNorm);
|
||
|
||
float coverage = baseNoise;
|
||
return verticalFalloff * coverage * topLayerAdd;
|
||
}
|
||
|
||
// Sample Cloud Density
|
||
float CalculateCloudDensity(float3 pos, float3 PlanetCenter, RaymarchParameters parameters, float4 weather, float mip, float lod, bool details)
|
||
{
|
||
const float baseFreq = 1e-5;
|
||
|
||
// Get Height fraction
|
||
float height = GetSamplingHeight(pos, PlanetCenter, parameters.cloudsParameter);
|
||
|
||
// wind settings
|
||
float cloud_top_offset = 2000.0;
|
||
float3 wind_direction = float3(_CloudsWindDirection.x, 0.0, _CloudsWindDirection.y);
|
||
|
||
// skew in wind direction
|
||
pos += height * wind_direction * cloud_top_offset;
|
||
|
||
float mip1 = mip + lod;
|
||
float4 coord = float4(pos * baseFreq * parameters.baseNoiseUV, mip1);
|
||
|
||
// Animate Wind
|
||
coord.xyz += float3(_CloudsWindDirection.z, 0.0f, _CloudsWindDirection.w) * 14;
|
||
|
||
float4 baseNoise = _Noise.SampleLevel(sampler_Noise, coord.xyz,coord.w) * parameters.baseNoiseMultiplier;
|
||
float low_freq_fBm = (baseNoise.g * 0.625) + (baseNoise.b * 0.25) + (baseNoise.a * 0.125);
|
||
float base_cloud = RemapEnviro(baseNoise.r, -(1.0 - low_freq_fBm) * (parameters.baseErosionIntensity), 1.0, 0.0, 1.0) ;
|
||
|
||
float targetShape = CloudVerticalShaping(height,parameters.bottomShape,parameters.midShape,parameters.topShape,parameters.rampShape);
|
||
float heightGradient = CloudTypeShaping(pos,saturate(weather.g + 0.1), parameters);
|
||
float shapedCloud = base_cloud * targetShape;
|
||
|
||
shapedCloud *= lerp(1.0, heightGradient, parameters.cloudTypeShaping);
|
||
shapedCloud += CloudTopLayer(height, base_cloud, parameters.topLayer);
|
||
|
||
|
||
float cloud_coverage = saturate(1-weather.r);
|
||
|
||
if(height > 0.90)
|
||
cloud_coverage = saturate(1-weather.b);
|
||
|
||
float cloudDensity = RemapEnviro(shapedCloud, cloud_coverage, 1.0, 0.0, 1.0);
|
||
|
||
//DETAIL
|
||
[branch]
|
||
if (details)
|
||
{
|
||
float mip2 = mip + lod;
|
||
coord = float4(pos * baseFreq * parameters.detailNoiseUV, mip2);
|
||
|
||
//Curl
|
||
float distToCam = distance(pos, _WorldSpaceCameraPos);
|
||
float curlFade = saturate(1.0 - distToCam / 20000.0f);
|
||
|
||
float2 curlA = _CurlNoise.SampleLevel(sampler_CurlNoise, coord.xz * 2, 0).rg * 2 - 1;
|
||
float2 curlB = _CurlNoise.SampleLevel(sampler_CurlNoise, coord.xy * 3, 0).rg * 2 - 1;
|
||
float2 curl = lerp(curlA, curlB, 0.5);
|
||
|
||
float curlAmp = 0.5 * parameters.attenuation * curlFade;
|
||
curl *= curlAmp * saturate(height * 2);
|
||
|
||
coord.xy += curl;
|
||
coord.xz += curl * 0.5;
|
||
|
||
coord.xyz += float3(_CloudsWindDirection.z * 14, _CloudsAnimation.z, _CloudsWindDirection.w * 14);
|
||
|
||
float3 detailNoise = _DetailNoise.SampleLevel(sampler_DetailNoise, coord.xyz, coord.w).rgb * parameters.detailNoiseMultiplier;
|
||
float high_freq_fBm = (detailNoise.r * 0.625) + (detailNoise.g * 0.25) + (detailNoise.b * 0.125);
|
||
float high_freq_noise_modifier = lerp(high_freq_fBm, 1.0f - high_freq_fBm, saturate(height * 8));
|
||
cloudDensity = RemapEnviro(cloudDensity, saturate(high_freq_noise_modifier * parameters.detailErosionIntensity), 1.0, 0.0, 1.0);
|
||
}
|
||
|
||
if(height > 0.9)
|
||
cloudDensity *= 0.2;
|
||
|
||
return cloudDensity;
|
||
}
|
||
|
||
|
||
|
||
static const float shadowSampleDistance[5] = {0.5, 2, 8, 12, 32};
|
||
static const float LightingInfluence[5] = {5, 4, 3, 2, 1};
|
||
|
||
float GetDensityAlongRay(float3 pos,float3 PlanetCenter,RaymarchParameters parameters,float3 LightDirection,float4 weather,float lod)
|
||
{
|
||
float mipBiasScale = 0.1;
|
||
float opticalDepth = 0.0;
|
||
float mipOffset = 0.0;
|
||
float distanceTraveled = 0.0;
|
||
|
||
[loop]
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
// Base step size from shadowSampleDistance
|
||
float baseStep = shadowSampleDistance[i] * (512.0 * _CloudsLightingExtended.z);
|
||
|
||
distanceTraveled += baseStep;
|
||
|
||
// Sample cloud density
|
||
float3 samplePos = pos + LightDirection * distanceTraveled;
|
||
float density = 0;
|
||
if(i < 4)
|
||
density = CalculateCloudDensity(samplePos, PlanetCenter, parameters, weather, mipOffset, lod, true) * 0.75;
|
||
else
|
||
density = CalculateCloudDensity(samplePos, PlanetCenter, parameters, weather, mipOffset, lod, false) * 0.75;
|
||
|
||
|
||
|
||
opticalDepth += LightingInfluence[i] * density * baseStep;
|
||
|
||
// Update mip offset proportionally
|
||
mipOffset += saturate(baseStep * mipBiasScale);
|
||
}
|
||
|
||
return opticalDepth;
|
||
}
|
||
|
||
|
||
float3 _LightningCenter;
|
||
float _LightningRadius;
|
||
float _LightningStart;
|
||
float _LightningDuration;
|
||
float _GlobalTime;
|
||
|
||
float LightningIntensity(float t)
|
||
{
|
||
if (t < 0 || t > _LightningDuration) return 0;
|
||
|
||
// ---- Parameters ----
|
||
float flickerStrength = 0.25; // 0..1 amplitude of flicker
|
||
float flickerCycles = 3; // number of flickers across duration
|
||
float endBoost = 2; // 1 = none, 2 = double brightness at end
|
||
|
||
// ---- Duration-based scaling ----
|
||
float riseRate = 1.0 / max(0.15 * _LightningDuration, 0.001);
|
||
float decayRate = 1.0 / max(_LightningDuration, 0.001);
|
||
|
||
float rise = saturate(t * riseRate);
|
||
float decay = exp(-t * decayRate * _LightningDuration);
|
||
float envelope = rise * decay;
|
||
|
||
// ---- Flicker ----
|
||
float flickerFreq = flickerCycles / max(_LightningDuration, 0.001);
|
||
float flicker = 1.0 + flickerStrength * sin(t * flickerFreq * 6.2831853);
|
||
|
||
// ---- Late-time boost ----
|
||
// Progress through flash (0 → 1)
|
||
float progress = saturate(t / _LightningDuration);
|
||
// Stronger near the end (ease-in curve)
|
||
float lateBoost = 1.0 + (endBoost - 1.0) * pow(progress, 3.0);
|
||
|
||
return envelope * flicker * lateBoost;
|
||
}
|
||
|
||
|
||
float SampleEnergy(
|
||
float3 pos, float cosTheta, float3 center,
|
||
RaymarchParameters p, float3 LightDirection,
|
||
float height, float ds_lod, float step_size,
|
||
float4 weather, float lod, float gradApprox)
|
||
{
|
||
//--------------------------------
|
||
// 1. Optical depth along light
|
||
//--------------------------------
|
||
float tau = GetDensityAlongRay(pos, center, p, LightDirection, weather, lod);
|
||
float sigma_t = max(p.lightAbsorb, 0.0005);
|
||
float opticalD = sigma_t * tau;
|
||
|
||
//--------------------------------
|
||
// 2. Direct scattering (HG + edge highlight coupled)
|
||
//--------------------------------
|
||
float T = exp(-opticalD);
|
||
float g = 0.85 - p.silverLiningSpread;
|
||
float hgForward = HenryGreensteinNorm(cosTheta, g);
|
||
float hgIso = 0.25 * INV_PI * p.edgeHighlightStrength;
|
||
float phase = hgIso + hgForward;
|
||
float direct = T * phase * p.scatteringCoef * 20.0 * max(_SolarTime,0.25) * p.silverLiningIntensity;
|
||
|
||
//--------------------------------
|
||
// 3. Multi-scattering (indirect)
|
||
//--------------------------------
|
||
float msEnergy = p.multiScatterStrength * (1.0 - T) * exp(-opticalD * p.multiScatterFalloff);
|
||
float phaseMS = 0.25 * INV_PI;
|
||
float indirect = msEnergy * phaseMS * p.scatteringCoef * 20.0;
|
||
|
||
//--------------------------------
|
||
// 3a Distance Clouds Tweaks
|
||
//--------------------------------
|
||
float distToCam = length(pos - _WorldSpaceCameraPos);
|
||
float distFactor = saturate(distToCam / 7000);
|
||
|
||
// Push balance toward indirect at distance
|
||
float indirectBoost = lerp(1.0, 1.5, distFactor); // 1.0 near, 1.5 far
|
||
float directFade = lerp(1.0, 0.7, distFactor); // keep direct a bit weaker far
|
||
|
||
direct *= directFade;
|
||
indirect *= indirectBoost;
|
||
|
||
//--------------------------------
|
||
// 4. Ambient floor
|
||
//--------------------------------
|
||
float ambientFloor = p.ambientFloor * (1.0 - exp(-opticalD * 0.1));
|
||
|
||
//--------------------------------
|
||
// 5. Lightning
|
||
//--------------------------------
|
||
float lightning = 0.0;
|
||
#if ENVIRO_LIGHTNING
|
||
float dist = length(pos - _LightningCenter);
|
||
float softness = 0.5;
|
||
float falloff = exp(-pow(dist / _LightningRadius, 2.0) * softness);
|
||
float flash = LightningIntensity(_Time.y - _LightningStart);
|
||
float densityAtten = exp(-tau * 0.004);
|
||
lightning = flash * falloff * densityAtten * 100.0 * (10 * saturate(1 - _SolarTime));
|
||
#endif
|
||
|
||
//--------------------------------
|
||
// 6. Combine total energy
|
||
//--------------------------------
|
||
float energy = direct + indirect + ambientFloor + lightning;
|
||
|
||
return max(energy * p.exposure, 0.0);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
float2 squareUV(float2 uv)
|
||
{
|
||
float width = _Resolution.x;
|
||
float height = _Resolution.y;
|
||
float scale = 400;
|
||
float x = uv.x * width;
|
||
float y = uv.y * height;
|
||
return float2 (x/scale, y/scale);
|
||
}
|
||
|
||
|
||
bool ray_trace_sphere(float3 center, float3 rd, float3 offset, float radius, out float t1, out float t2) {
|
||
float3 p = center - offset;
|
||
float b = dot(p, rd);
|
||
float c = dot(p, p) - (radius * radius);
|
||
|
||
float f = b * b - c;
|
||
if (f >= 0.0) {
|
||
float dem = sqrt(f);
|
||
t1 = -b - dem;
|
||
t2 = -b + dem;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
|
||
bool resolve_ray_start_end(float3 ws_origin, float3 ws_ray, float3 center, RaymarchParameters parameter, out float start, out float end)
|
||
{
|
||
start = 0;
|
||
end = 0;
|
||
//case includes on ground, inside atm, above atm.
|
||
float ot1, ot2, it1, it2;
|
||
bool outIntersected = ray_trace_sphere(ws_origin, ws_ray, center, parameter.cloudsParameter.w + parameter.cloudsParameter.y, ot1, ot2);
|
||
if (!outIntersected || ot2 < 0.0f)
|
||
return false; //you see nothing.
|
||
|
||
bool inIntersected = ray_trace_sphere(ws_origin, ws_ray, center, parameter.cloudsParameter.w + parameter.cloudsParameter.x, it1, it2);
|
||
|
||
if (inIntersected)
|
||
{
|
||
if (it1 * it2 < 0)
|
||
{
|
||
//we're on ground.
|
||
start = max(it2, 0);
|
||
end = ot2;
|
||
}
|
||
else
|
||
{
|
||
start = 0.0f;
|
||
//we're inside atm, or above atm.
|
||
if (ot1 * ot2 < 0.0)
|
||
{
|
||
//Inside atm.
|
||
if (it2 > 0.0)
|
||
{
|
||
//Look down.
|
||
end = it1;
|
||
}
|
||
else
|
||
{
|
||
//Look up.
|
||
end = ot2;
|
||
}
|
||
|
||
start = 0.0f;
|
||
}
|
||
else
|
||
{ //Outside atm
|
||
if (ot1 < 0.0)
|
||
{
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
start = ot1;
|
||
end = it1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
end = ot2;
|
||
start = max(ot1, 0);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
int inside = 0;
|
||
|
||
float2 ResolveRay(float3 pos, float3 ray, float3 center, float raymarchEnd, RaymarchParameters parameter)
|
||
{
|
||
float sampleStart = 0;
|
||
float sampleEnd = 0;
|
||
|
||
if (!resolve_ray_start_end(pos, ray,center, parameter, sampleStart, sampleEnd))
|
||
{
|
||
return float2(0,0);
|
||
}
|
||
|
||
float3 sampleStartPos = pos + (ray * sampleStart);
|
||
if (sampleEnd <= sampleStart)
|
||
{
|
||
return float2(0,0);
|
||
}
|
||
|
||
float ch = length(pos - center) - parameter.cloudsParameter.w;
|
||
//float height = RemapEnviro(pos.y, parameter.cloudsParameter.x, parameter.cloudsParameter.y * 0.75, 0, 1);
|
||
//float end = lerp(_CloudsCoverageSettings.y * 0.85,_CloudsCoverageSettings.y * 1.25,height);
|
||
|
||
raymarchEnd = min(raymarchEnd, _CloudsCoverageSettings.y);
|
||
|
||
if (ch < parameter.cloudsParameter.x)
|
||
{
|
||
sampleEnd = min(raymarchEnd, sampleEnd);
|
||
inside = 0;
|
||
|
||
if(ray.y < 0)
|
||
return float2(0,0);
|
||
}
|
||
else if (ch > parameter.cloudsParameter.y)
|
||
{
|
||
sampleEnd = min(raymarchEnd, sampleEnd);
|
||
inside = 0;
|
||
}
|
||
else
|
||
{
|
||
sampleEnd = min(raymarchEnd, sampleEnd);
|
||
inside = 0;
|
||
}
|
||
|
||
return float2(max(0.0f,sampleStart), min(raymarchEnd, sampleEnd));
|
||
}
|
||
|
||
float CalculateLodMips(float distanceToCamera)
|
||
{
|
||
return lerp(0.0, lerp(5.0,0.0,_LODDistance), saturate((distanceToCamera - 3000.0) / (100000.0 - 3000.0)));
|
||
}
|
||
|
||
|
||
float3 Raymarch (float3 cameraPos, float3 ray, float2 hitDistance, float3 center, RaymarchParameters parameters, float offset)
|
||
{
|
||
float cloud_test = 0.0;
|
||
int zero_density_sample_count = 0;
|
||
float sampled_density_previous = -1.0;
|
||
|
||
float alpha = 1.0;
|
||
float intensity = 0.0;
|
||
float depth = 0.0;
|
||
float depthWeightSum = 0.000001;
|
||
float trans = 1.0f;
|
||
|
||
int steps = (int)lerp(parameters.minSteps, parameters.maxSteps, ray.y);
|
||
|
||
//int steps = parameters.maxSteps;
|
||
float rayStepLength = (hitDistance.y - hitDistance.x) / steps;
|
||
float3 rayStep = ray * rayStepLength;
|
||
|
||
float3 pos = (cameraPos + (hitDistance.x) * ray);
|
||
pos += (offset * rayStepLength) * ray;
|
||
//pos += rayStep;
|
||
pos += rayStep;
|
||
float3 sampleEndPos = cameraPos + ray * hitDistance.y;
|
||
float eyeToEnd = distance(cameraPos, sampleEndPos);
|
||
float cosTheta = dot(ray, normalize(_LightDir));
|
||
|
||
[loop]
|
||
for (int i = 0; i < steps; i++)
|
||
{
|
||
|
||
//Calculate projection height
|
||
float height = GetSamplingHeight(pos, center, parameters.cloudsParameter);
|
||
|
||
//Get out of expensive raymarching
|
||
if (alpha <= 0.01 || height > 1.0 || height < 0.0 || _CloudsCoverageSettings.x <= -0.9)
|
||
break;
|
||
|
||
// Get Weather Data
|
||
float4 weather = GetWeather(pos);
|
||
|
||
float distanceToCamera = length(pos - cameraPos);
|
||
float lod = CalculateLodMips(distanceToCamera);
|
||
|
||
if (cloud_test > 0.0)
|
||
{
|
||
float sampled_density = CalculateCloudDensity(pos, center, parameters, weather, 0, lod, true);
|
||
|
||
if (sampled_density == 0.0 && sampled_density_previous == 0.0)
|
||
{
|
||
zero_density_sample_count++;
|
||
}
|
||
|
||
if (zero_density_sample_count < 8 && sampled_density != 0.0)
|
||
{
|
||
float extinction = pow(max(parameters.density * sampled_density,0.001),parameters.densitySmoothness);
|
||
float clampedExtinction = max(extinction, 1e-7);
|
||
|
||
float transmittance = exp(-extinction * rayStepLength);
|
||
|
||
float gradApprox = abs(sampled_density - sampled_density_previous);
|
||
|
||
// edge-sensitive ds_lod
|
||
float ds_lod_local = sampled_density * (1.0 + lod * 0.8);
|
||
|
||
float luminance = SampleEnergy(pos, cosTheta, center, parameters, _LightDir, height, sampled_density, rayStepLength,weather,lod,gradApprox);
|
||
|
||
float integScatt = (luminance - luminance * transmittance);
|
||
|
||
float depthWeight = trans;
|
||
depth += depthWeight * distanceToCamera;
|
||
depthWeightSum += depthWeight;
|
||
|
||
intensity += trans * integScatt;
|
||
|
||
trans *= transmittance;
|
||
alpha *= max(transmittance, 0.0);
|
||
|
||
if (alpha <= 0.01)
|
||
alpha = 0.0;
|
||
}
|
||
// if not, then set cloud_test to zero so that we go back to the cheap sample case
|
||
else if(zero_density_sample_count >= 8)
|
||
{
|
||
cloud_test = 0.0;
|
||
zero_density_sample_count = 0;
|
||
}
|
||
|
||
sampled_density_previous = sampled_density;
|
||
pos += rayStep;
|
||
}
|
||
else
|
||
{
|
||
// sample density the cheap way, only using the low frequency noise
|
||
cloud_test = CalculateCloudDensity(pos, center, parameters, weather, 0, lod, (bool)inside);
|
||
|
||
if (cloud_test == 0.0)
|
||
{
|
||
pos += rayStep * 2;
|
||
}
|
||
else //take a step back and capture area we skipped.
|
||
{
|
||
pos -= rayStep;
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
float distance = depth / depthWeightSum;
|
||
|
||
if (distance <= 0.0)
|
||
{
|
||
distance = length(sampleEndPos - cameraPos);
|
||
}
|
||
|
||
alpha = saturate(1.0f - alpha);
|
||
|
||
return float3(intensity,distance,alpha);
|
||
|
||
}
|
||
|
||
float3 CalculateWorldPosition (float2 uv, float depth)
|
||
{
|
||
float4x4 proj, eyeToWorld;
|
||
|
||
if (unity_StereoEyeIndex == 0)
|
||
{
|
||
proj = _LeftViewFromScreen;
|
||
eyeToWorld = _LeftWorldFromView;
|
||
}
|
||
else
|
||
{
|
||
proj = _RightViewFromScreen;
|
||
eyeToWorld = _RightWorldFromView;
|
||
}
|
||
|
||
//bit of matrix math to take the screen space coord (u,v,depth) and transform to world space
|
||
float2 uvClip = uv * 2.0 - 1.0;
|
||
float clipDepth = depth; // Fix for OpenGl Core thanks to Lars Bertram
|
||
clipDepth = (UNITY_NEAR_CLIP_VALUE < 0) ? clipDepth * 2 - 1 : clipDepth;
|
||
float4 clipPos = float4(uvClip, clipDepth, 1.0);
|
||
float4 viewPos = mul(proj, clipPos); // inverse projection by clip position
|
||
viewPos /= viewPos.w; // perspective division
|
||
return float3(mul(eyeToWorld, viewPos).xyz);
|
||
}
|
||
|
||
float RaymarchShadows (float3 cameraPos, float3 worldPos,float3 ray,float3 center, RaymarchParameters parameters, float offset,float depth)
|
||
{
|
||
if(depth == 0.0f)
|
||
return 0.0;
|
||
|
||
int steps = 16;
|
||
float worldDotLight = saturate(dot(float3(0, 1, 0), _LightDir));
|
||
float bottomDist = max(0, parameters.cloudsParameter.x ) / worldDotLight;
|
||
float topDist = max(0, parameters.cloudsParameter.y ) / worldDotLight;
|
||
|
||
float rayStepLength = (topDist - bottomDist) / steps;
|
||
float3 rayStep = _LightDir * rayStepLength;
|
||
|
||
float3 pos = worldPos + bottomDist * _LightDir;
|
||
|
||
float4 weather = GetWeather(pos);
|
||
float intensity = 0.05;
|
||
|
||
float shadowIntensity = 0.0;
|
||
|
||
float _Softness = 2.0f;
|
||
|
||
[unroll]
|
||
for (int i = 0; i < steps; i++)
|
||
{
|
||
float3 samplePos = rayStepLength * i * _LightDir + pos;
|
||
float sampleResult = CalculateCloudDensity(samplePos, center, parameters, weather, 0, 0, true) * intensity;
|
||
float result = sampleResult * (rayStepLength / (i + 1));
|
||
shadowIntensity += result;
|
||
|
||
// if (shadowIntensity > 0.99)
|
||
// break;
|
||
}
|
||
return (shadowIntensity);
|
||
} |