92 lines
3.4 KiB
GLSL
92 lines
3.4 KiB
GLSL
precision mediump float;
|
|
|
|
attribute vec3 aVertexPosition;
|
|
attribute vec3 aNormal;
|
|
attribute vec3 aColor;
|
|
|
|
uniform vec3 v3CameraPosition; // The camera position
|
|
uniform vec3 v3LightPosition; // The direction vector to the light source
|
|
uniform vec3 v3InvWavelength; // 1 / pow(wavelength, 4) for the red, green, and blue channels
|
|
uniform float fCameraHeight; // The camera's current height
|
|
uniform float fCameraHeight2; // fCameraHeight^2
|
|
uniform float fOuterRadius; // The outer (atmosphere) radius
|
|
uniform float fOuterRadius2; // fOuterRadius^2
|
|
uniform float fInnerRadius; // The inner (planetary) radius
|
|
uniform float fInnerRadius2; // fInnerRadius^2
|
|
uniform float fKrESun; // Kr * ESun
|
|
uniform float fKmESun; // Km * ESun
|
|
uniform float fKr4PI; // Kr * 4 * PI
|
|
uniform float fKm4PI; // Km * 4 * PI
|
|
uniform float fScale; // 1 / (fOuterRadius - fInnerRadius)
|
|
uniform float fScaleDepth; // The scale depth (i.e. the altitude at which the atmosphere's average density is found)
|
|
uniform float fScaleOverScaleDepth; // fScale / fScaleDepth
|
|
|
|
const int nSamples = 3;
|
|
const float fSamples = 3.0;
|
|
|
|
varying vec3 c0;
|
|
varying vec3 c1;
|
|
varying vec3 vNormal;
|
|
varying vec3 vColor;
|
|
|
|
uniform mat4 uModelMatrix;
|
|
uniform mat4 uViewMatrix;
|
|
uniform mat4 uProjectionMatrix;
|
|
|
|
float scale(float fCos) {
|
|
float x = 1.0 - fCos;
|
|
return fScaleDepth * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));
|
|
}
|
|
|
|
void main(void) {
|
|
// Get the ray from the camera to the vertex and its length (which is the far point of the ray passing through the atmosphere)
|
|
vec3 v3Ray = aVertexPosition - v3CameraPosition;
|
|
float fFar = length(v3Ray);
|
|
v3Ray /= fFar;
|
|
|
|
// Calculate the closest intersection of the ray with the outer atmosphere (which is the near point of the ray passing through the atmosphere)
|
|
float B = 2.0 * dot(v3CameraPosition, v3Ray);
|
|
float C = fCameraHeight2 - fOuterRadius2;
|
|
float fDet = max(0.0, B*B - 4.0 * C);
|
|
float fNear = 0.5 * (-B - sqrt(fDet));
|
|
|
|
// Calculate the ray's starting position, then calculate its scattering offset
|
|
vec3 v3Start = v3CameraPosition + v3Ray * fNear;
|
|
fFar -= fNear;
|
|
float fDepth = exp((fInnerRadius - fOuterRadius) / fScaleDepth);
|
|
float fCameraAngle = dot(-v3Ray, aVertexPosition) / length(aVertexPosition);
|
|
float fLightAngle = dot(v3LightPosition, aVertexPosition) / length(aVertexPosition);
|
|
|
|
float fCameraScale = scale(fCameraAngle);
|
|
float fLightScale = scale(fLightAngle);
|
|
float fCameraOffset = fDepth*fCameraScale;
|
|
float fTemp = (fLightScale + fCameraScale);
|
|
|
|
// Initialize the scattering loop variables
|
|
float fSampleLength = fFar / fSamples;
|
|
float fScaledLength = fSampleLength * fScale;
|
|
vec3 v3SampleRay = v3Ray * fSampleLength;
|
|
vec3 v3SamplePoint = v3Start + v3SampleRay * 0.5;
|
|
|
|
// Now loop through the sample rays
|
|
vec3 v3FrontColor = vec3(0.0, 0.0, 0.0);
|
|
vec3 v3Attenuate;
|
|
for(int i=0; i<nSamples; i++)
|
|
{
|
|
float fHeight = length(v3SamplePoint);
|
|
float fDepth = exp(fScaleOverScaleDepth * (fInnerRadius - fHeight));
|
|
float fScatter = fDepth*fTemp - fCameraOffset;
|
|
v3Attenuate = exp(-fScatter * (v3InvWavelength * fKr4PI + fKm4PI));
|
|
v3FrontColor += v3Attenuate * (fDepth * fScaledLength);
|
|
v3SamplePoint += v3SampleRay;
|
|
}
|
|
|
|
// Calculate the attenuation factor for the ground
|
|
c0 = v3Attenuate;
|
|
c1 = v3FrontColor * (v3InvWavelength * fKrESun + fKmESun);
|
|
|
|
gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * vec4(aVertexPosition,1);
|
|
vColor = aColor;
|
|
vNormal = aNormal;
|
|
}
|