This file implements the API of our atmosphere model. Its main role is to precompute the transmittance, scattering and irradiance textures. The GLSL functions to precompute them are provided in functions.glsl, but they are not sufficient. They must be used in fully functional shaders and programs, and these programs must be called in the correct order, with the correct input and output textures (via framebuffer objects), to precompute each scattering order in sequence, as described in Algorithm 4.1 of our paper. This is the role of the following C++ code.
#include "atmosphere/model.h" #include <glad/glad.h> #include <cassert> #include <cmath> #include <iostream> #include <memory> #include "atmosphere/constants.h"
The rest of this file is organized in 3 parts:
Model class, using the above tools.In order to precompute a texture we attach it to a framebuffer object (FBO) and we render a full quad in this FBO. For this we need a basic vertex shader:
namespace atmosphere {
namespace {
const char kVertexShader[] = R"(
#version 330
layout(location = 0) in vec2 vertex;
void main() {
gl_Position = vec4(vertex, 0.0, 1.0);
})";
a basic geometry shader (only for 3D textures, to specify in which layer we want to write):
const char kGeometryShader[] = R"(
#version 330
layout(triangles) in;
layout(triangle_strip, max_vertices = 3) out;
uniform int layer;
void main() {
gl_Position = gl_in[0].gl_Position;
gl_Layer = layer;
EmitVertex();
gl_Position = gl_in[1].gl_Position;
gl_Layer = layer;
EmitVertex();
gl_Position = gl_in[2].gl_Position;
gl_Layer = layer;
EmitVertex();
EndPrimitive();
})";
and a fragment shader, which depends on the texture we want to compute. This
is the role of the following shaders, which simply wrap the precomputation
functions from functions.glsl in complete
shaders (with a main function and a proper declaration of the
shader inputs and outputs). Note that these strings must be concatenated with
definitions.glsl and functions.glsl (provided as C++
string literals by the generated .glsl.inc files), as well as with
a definition of the ATMOSPHERE constant - containing the atmosphere
parameters, to really get a complete shader. Note also the
luminance_from_radiance uniforms: these are used in precomputed
illuminance mode to convert the radiance values computed by the
functions.glsl functions to luminance values (see the
Init method for more details).
#include "atmosphere/definitions.glsl.inc"
#include "atmosphere/functions.glsl.inc"
const char kComputeTransmittanceShader[] = R"(
layout(location = 0) out vec3 transmittance;
void main() {
transmittance = ComputeTransmittanceToTopAtmosphereBoundaryTexture(
ATMOSPHERE, gl_FragCoord.xy);
})";
const char kComputeDirectIrradianceShader[] = R"(
layout(location = 0) out vec3 delta_irradiance;
layout(location = 1) out vec3 irradiance;
uniform sampler2D transmittance_texture;
void main() {
delta_irradiance = ComputeDirectIrradianceTexture(
ATMOSPHERE, transmittance_texture, gl_FragCoord.xy);
irradiance = vec3(0.0);
})";
const char kComputeSingleScatteringShader[] = R"(
layout(location = 0) out vec3 delta_rayleigh;
layout(location = 1) out vec3 delta_mie;
layout(location = 2) out vec4 scattering;
layout(location = 3) out vec3 single_mie_scattering;
uniform mat3 luminance_from_radiance;
uniform sampler2D transmittance_texture;
uniform int layer;
void main() {
ComputeSingleScatteringTexture(
ATMOSPHERE, transmittance_texture, vec3(gl_FragCoord.xy, layer + 0.5),
delta_rayleigh, delta_mie);
scattering = vec4(luminance_from_radiance * delta_rayleigh.rgb,
(luminance_from_radiance * delta_mie).r);
single_mie_scattering = luminance_from_radiance * delta_mie;
})";
const char kComputeScatteringDensityShader[] = R"(
layout(location = 0) out vec3 scattering_density;
uniform sampler2D transmittance_texture;
uniform sampler3D single_rayleigh_scattering_texture;
uniform sampler3D single_mie_scattering_texture;
uniform sampler3D multiple_scattering_texture;
uniform sampler2D irradiance_texture;
uniform int scattering_order;
uniform int layer;
void main() {
scattering_density = ComputeScatteringDensityTexture(
ATMOSPHERE, transmittance_texture, single_rayleigh_scattering_texture,
single_mie_scattering_texture, multiple_scattering_texture,
irradiance_texture, vec3(gl_FragCoord.xy, layer + 0.5),
scattering_order);
})";
const char kComputeIndirectIrradianceShader[] = R"(
layout(location = 0) out vec3 delta_irradiance;
layout(location = 1) out vec3 irradiance;
uniform mat3 luminance_from_radiance;
uniform sampler3D single_rayleigh_scattering_texture;
uniform sampler3D single_mie_scattering_texture;
uniform sampler3D multiple_scattering_texture;
uniform int scattering_order;
void main() {
delta_irradiance = ComputeIndirectIrradianceTexture(
ATMOSPHERE, single_rayleigh_scattering_texture,
single_mie_scattering_texture, multiple_scattering_texture,
gl_FragCoord.xy, scattering_order);
irradiance = luminance_from_radiance * delta_irradiance;
})";
const char kComputeMultipleScatteringShader[] = R"(
layout(location = 0) out vec3 delta_multiple_scattering;
layout(location = 1) out vec4 scattering;
uniform mat3 luminance_from_radiance;
uniform sampler2D transmittance_texture;
uniform sampler3D scattering_density_texture;
uniform int layer;
void main() {
float nu;
delta_multiple_scattering = ComputeMultipleScatteringTexture(
ATMOSPHERE, transmittance_texture, scattering_density_texture,
vec3(gl_FragCoord.xy, layer + 0.5), nu);
scattering = vec4(
luminance_from_radiance *
delta_multiple_scattering.rgb / RayleighPhaseFunction(nu),
0.0);
})";
We finally need a shader implementing the GLSL functions exposed in our API,
which can be done by calling the corresponding functions in
functions.glsl, with the precomputed
texture arguments taken from uniform variables (note also the
*_RADIANCE_TO_LUMINANCE conversion constants in the last functions:
they are computed in the second part below, and their
definitions are concatenated to this GLSL code to get a fully functional
shader).
const char kAtmosphereShader[] = R"(
uniform sampler2D transmittance_texture;
uniform sampler3D scattering_texture;
uniform sampler3D single_mie_scattering_texture;
uniform sampler2D irradiance_texture;
#ifdef RADIANCE_API_ENABLED
RadianceSpectrum GetSolarRadiance() {
return ATMOSPHERE.solar_irradiance /
(PI * ATMOSPHERE.sun_angular_radius * ATMOSPHERE.sun_angular_radius);
}
RadianceSpectrum GetSkyRadiance(
Position camera, Direction view_ray, Length shadow_length,
Direction sun_direction, out DimensionlessSpectrum transmittance) {
return GetSkyRadiance(ATMOSPHERE, transmittance_texture,
scattering_texture, single_mie_scattering_texture,
camera, view_ray, shadow_length, sun_direction, transmittance);
}
RadianceSpectrum GetSkyRadianceToPoint(
Position camera, Position point, Length shadow_length,
Direction sun_direction, out DimensionlessSpectrum transmittance) {
return GetSkyRadianceToPoint(ATMOSPHERE, transmittance_texture,
scattering_texture, single_mie_scattering_texture,
camera, point, shadow_length, sun_direction, transmittance);
}
IrradianceSpectrum GetSunAndSkyIrradiance(
Position p, Direction normal, Direction sun_direction,
out IrradianceSpectrum sky_irradiance) {
return GetSunAndSkyIrradiance(ATMOSPHERE, transmittance_texture,
irradiance_texture, p, normal, sun_direction, sky_irradiance);
}
#endif
Luminance3 GetSolarLuminance() {
return ATMOSPHERE.solar_irradiance /
(PI * ATMOSPHERE.sun_angular_radius * ATMOSPHERE.sun_angular_radius) *
SUN_SPECTRAL_RADIANCE_TO_LUMINANCE;
}
Luminance3 GetSkyLuminance(
Position camera, Direction view_ray, Length shadow_length,
Direction sun_direction, out DimensionlessSpectrum transmittance) {
return GetSkyRadiance(ATMOSPHERE, transmittance_texture,
scattering_texture, single_mie_scattering_texture,
camera, view_ray, shadow_length, sun_direction, transmittance) *
SKY_SPECTRAL_RADIANCE_TO_LUMINANCE;
}
Luminance3 GetSkyLuminanceToPoint(
Position camera, Position point, Length shadow_length,
Direction sun_direction, out DimensionlessSpectrum transmittance) {
return GetSkyRadianceToPoint(ATMOSPHERE, transmittance_texture,
scattering_texture, single_mie_scattering_texture,
camera, point, shadow_length, sun_direction, transmittance) *
SKY_SPECTRAL_RADIANCE_TO_LUMINANCE;
}
Illuminance3 GetSunAndSkyIlluminance(
Position p, Direction normal, Direction sun_direction,
out IrradianceSpectrum sky_irradiance) {
IrradianceSpectrum sun_irradiance = GetSunAndSkyIrradiance(
ATMOSPHERE, transmittance_texture, irradiance_texture, p, normal,
sun_direction, sky_irradiance);
sky_irradiance *= SKY_SPECTRAL_RADIANCE_TO_LUMINANCE;
return sun_irradiance * SUN_SPECTRAL_RADIANCE_TO_LUMINANCE;
})";
To compile and link these shaders into programs, and to set their uniforms, we use the following utility class:
class Program {
public:
Program(
const std::string& vertex_shader_source,
const std::string& fragment_shader_source)
: Program(vertex_shader_source, "", fragment_shader_source) {
}
Program(
const std::string& vertex_shader_source,
const std::string& geometry_shader_source,
const std::string& fragment_shader_source) {
program_ = glCreateProgram();
const char* source;
source = vertex_shader_source.c_str();
GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &source, NULL);
glCompileShader(vertex_shader);
CheckShader(vertex_shader);
glAttachShader(program_, vertex_shader);
GLuint geometry_shader = 0;
if (!geometry_shader_source.empty()) {
source = geometry_shader_source.c_str();
geometry_shader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geometry_shader, 1, &source, NULL);
glCompileShader(geometry_shader);
CheckShader(geometry_shader);
glAttachShader(program_, geometry_shader);
}
source = fragment_shader_source.c_str();
GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &source, NULL);
glCompileShader(fragment_shader);
CheckShader(fragment_shader);
glAttachShader(program_, fragment_shader);
glLinkProgram(program_);
CheckProgram(program_);
glDetachShader(program_, vertex_shader);
glDeleteShader(vertex_shader);
if (!geometry_shader_source.empty()) {
glDetachShader(program_, geometry_shader);
glDeleteShader(geometry_shader);
}
glDetachShader(program_, fragment_shader);
glDeleteShader(fragment_shader);
}
~Program() {
glDeleteProgram(program_);
}
void Use() const {
glUseProgram(program_);
}
void BindMat3(const std::string& uniform_name,
const std::array<float, 9>& value) const {
glUniformMatrix3fv(glGetUniformLocation(program_, uniform_name.c_str()),
1, true /* transpose */, value.data());
}
void BindInt(const std::string& uniform_name, int value) const {
glUniform1i(glGetUniformLocation(program_, uniform_name.c_str()), value);
}
void BindTexture2d(const std::string& sampler_uniform_name, GLuint texture,
GLuint texture_unit) const {
glActiveTexture(GL_TEXTURE0 + texture_unit);
glBindTexture(GL_TEXTURE_2D, texture);
BindInt(sampler_uniform_name, texture_unit);
}
void BindTexture3d(const std::string& sampler_uniform_name, GLuint texture,
GLuint texture_unit) const {
glActiveTexture(GL_TEXTURE0 + texture_unit);
glBindTexture(GL_TEXTURE_3D, texture);
BindInt(sampler_uniform_name, texture_unit);
}
private:
static void CheckShader(GLuint shader) {
GLint compile_status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
if (compile_status == GL_FALSE) {
PrintShaderLog(shader);
}
assert(compile_status == GL_TRUE);
}
static void PrintShaderLog(GLuint shader) {
GLint log_length;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
std::unique_ptr<char[]> log_data(new char[log_length]);
glGetShaderInfoLog(shader, log_length, &log_length, log_data.get());
std::cerr << "compile log = "
<< std::string(log_data.get(), log_length) << std::endl;
}
}
static void CheckProgram(GLuint program) {
GLint link_status;
glGetProgramiv(program, GL_LINK_STATUS, &link_status);
if (link_status == GL_FALSE) {
PrintProgramLog(program);
}
assert(link_status == GL_TRUE);
assert(glGetError() == 0);
}
static void PrintProgramLog(GLuint program) {
GLint log_length;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
std::unique_ptr<char[]> log_data(new char[log_length]);
glGetProgramInfoLog(program, log_length, &log_length, log_data.get());
std::cerr << "link log = "
<< std::string(log_data.get(), log_length) << std::endl;
}
}
GLuint program_;
};
We also need functions to allocate the precomputed textures on GPU:
GLuint NewTexture2d(int width, int height) {
GLuint texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
// 16F precision for the transmittance gives artifacts.
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0,
GL_RGBA, GL_FLOAT, NULL);
return texture;
}
GLuint NewTexture3d(int width, int height, int depth, GLenum format,
bool half_precision) {
GLuint texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_3D, texture);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
GLenum internal_format = format == GL_RGBA ?
(half_precision ? GL_RGBA16F : GL_RGBA32F) :
(half_precision ? GL_RGB16F : GL_RGB32F);
glTexImage3D(GL_TEXTURE_3D, 0, internal_format, width, height, depth, 0,
format, GL_FLOAT, NULL);
return texture;
}
a function to test whether the RGB format is a supported renderbuffer color format (the OpenGL 3.3 Core Profile specification requires support for the RGBA formats, but not for the RGB ones):
bool IsFramebufferRgbFormatSupported(bool half_precision) {
GLuint test_fbo = 0;
glGenFramebuffers(1, &test_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, test_fbo);
GLuint test_texture = 0;
glGenTextures(1, &test_texture);
glBindTexture(GL_TEXTURE_2D, test_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, half_precision ? GL_RGB16F : GL_RGB32F,
1, 1, 0, GL_RGB, GL_FLOAT, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, test_texture, 0);
bool rgb_format_supported =
glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
glDeleteTextures(1, &test_texture);
glDeleteFramebuffers(1, &test_fbo);
return rgb_format_supported;
}
and a function to draw a full screen quad in an offscreen framebuffer (with blending separately enabled or disabled for each color attachment):
void DrawQuad(const std::vector<bool>& enable_blend, GLuint quad_vao) {
for (unsigned int i = 0; i < enable_blend.size(); ++i) {
if (enable_blend[i]) {
glEnablei(GL_BLEND, i);
}
}
glBindVertexArray(quad_vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
for (unsigned int i = 0; i < enable_blend.size(); ++i) {
glDisablei(GL_BLEND, i);
}
}
Finally, we need a utility function to compute the value of the conversion
constants *_RADIANCE_TO_LUMINANCE, used above to convert the
spectral results into luminance values. These are the constants k_r, k_g, k_b
described in Section 14.3 of A
Qualitative and Quantitative Evaluation of 8 Clear Sky Models.
Computing their value requires an integral of a function times a CIE color matching function. Thus, we first need functions to interpolate an arbitrary function (specified by some samples), and a CIE color matching function (specified by tabulated values), at an arbitrary wavelength. This is the purpose of the following two functions:
constexpr int kLambdaMin = 360;
constexpr int kLambdaMax = 830;
double CieColorMatchingFunctionTableValue(double wavelength, int column) {
if (wavelength <= kLambdaMin || wavelength >= kLambdaMax) {
return 0.0;
}
double u = (wavelength - kLambdaMin) / 5.0;
int row = static_cast<int>(std::floor(u));
assert(row >= 0 && row + 1 < 95);
assert(CIE_2_DEG_COLOR_MATCHING_FUNCTIONS[4 * row] <= wavelength &&
CIE_2_DEG_COLOR_MATCHING_FUNCTIONS[4 * (row + 1)] >= wavelength);
u -= row;
return CIE_2_DEG_COLOR_MATCHING_FUNCTIONS[4 * row + column] * (1.0 - u) +
CIE_2_DEG_COLOR_MATCHING_FUNCTIONS[4 * (row + 1) + column] * u;
}
double Interpolate(
const std::vector<double>& wavelengths,
const std::vector<double>& wavelength_function,
double wavelength) {
assert(wavelength_function.size() == wavelengths.size());
if (wavelength < wavelengths[0]) {
return wavelength_function[0];
}
for (unsigned int i = 0; i < wavelengths.size() - 1; ++i) {
if (wavelength < wavelengths[i + 1]) {
double u =
(wavelength - wavelengths[i]) / (wavelengths[i + 1] - wavelengths[i]);
return
wavelength_function[i] * (1.0 - u) + wavelength_function[i + 1] * u;
}
}
return wavelength_function[wavelength_function.size() - 1];
}
We can then implement a utility function to compute the "spectral radiance to luminance" conversion constants (see Section 14.3 in A Qualitative and Quantitative Evaluation of 8 Clear Sky Models for their definitions):
// The returned constants are in lumen.nm / watt.
void ComputeSpectralRadianceToLuminanceFactors(
const std::vector<double>& wavelengths,
const std::vector<double>& solar_irradiance,
double lambda_power, double* k_r, double* k_g, double* k_b) {
*k_r = 0.0;
*k_g = 0.0;
*k_b = 0.0;
double solar_r = Interpolate(wavelengths, solar_irradiance, Model::kLambdaR);
double solar_g = Interpolate(wavelengths, solar_irradiance, Model::kLambdaG);
double solar_b = Interpolate(wavelengths, solar_irradiance, Model::kLambdaB);
int dlambda = 1;
for (int lambda = kLambdaMin; lambda < kLambdaMax; lambda += dlambda) {
double x_bar = CieColorMatchingFunctionTableValue(lambda, 1);
double y_bar = CieColorMatchingFunctionTableValue(lambda, 2);
double z_bar = CieColorMatchingFunctionTableValue(lambda, 3);
const double* xyz2srgb = XYZ_TO_SRGB;
double r_bar =
xyz2srgb[0] * x_bar + xyz2srgb[1] * y_bar + xyz2srgb[2] * z_bar;
double g_bar =
xyz2srgb[3] * x_bar + xyz2srgb[4] * y_bar + xyz2srgb[5] * z_bar;
double b_bar =
xyz2srgb[6] * x_bar + xyz2srgb[7] * y_bar + xyz2srgb[8] * z_bar;
double irradiance = Interpolate(wavelengths, solar_irradiance, lambda);
*k_r += r_bar * irradiance / solar_r *
pow(lambda / Model::kLambdaR, lambda_power);
*k_g += g_bar * irradiance / solar_g *
pow(lambda / Model::kLambdaG, lambda_power);
*k_b += b_bar * irradiance / solar_b *
pow(lambda / Model::kLambdaB, lambda_power);
}
*k_r *= MAX_LUMINOUS_EFFICACY * dlambda;
*k_g *= MAX_LUMINOUS_EFFICACY * dlambda;
*k_b *= MAX_LUMINOUS_EFFICACY * dlambda;
}
} // anonymous namespace
Using the above utility functions and classes, we can now implement the
constructor of the Model class. This constructor generates a piece
of GLSL code that defines an ATMOSPHERE constant containing the
atmosphere parameters (we use constants instead of uniforms to enable constant
folding and propagation optimizations in the GLSL compiler), concatenated with
functions.glsl, and with
kAtmosphereShader, to get the shader exposed by our API in
GetShader. It also allocates the precomputed textures (but does not
initialize them), as well as a vertex buffer object to render a full screen quad
(used to render into the precomputed textures).
Model::Model(
const std::vector<double>& wavelengths,
const std::vector<double>& solar_irradiance,
const double sun_angular_radius,
double bottom_radius,
double top_radius,
const std::vector<DensityProfileLayer>& rayleigh_density,
const std::vector<double>& rayleigh_scattering,
const std::vector<DensityProfileLayer>& mie_density,
const std::vector<double>& mie_scattering,
const std::vector<double>& mie_extinction,
double mie_phase_function_g,
const std::vector<DensityProfileLayer>& absorption_density,
const std::vector<double>& absorption_extinction,
const std::vector<double>& ground_albedo,
double max_sun_zenith_angle,
double length_unit_in_meters,
unsigned int num_precomputed_wavelengths,
bool combine_scattering_textures,
bool half_precision) :
num_precomputed_wavelengths_(num_precomputed_wavelengths),
half_precision_(half_precision),
rgb_format_supported_(IsFramebufferRgbFormatSupported(half_precision)) {
auto to_string = [&wavelengths](const std::vector<double>& v,
const vec3& lambdas, double scale) {
double r = Interpolate(wavelengths, v, lambdas[0]) * scale;
double g = Interpolate(wavelengths, v, lambdas[1]) * scale;
double b = Interpolate(wavelengths, v, lambdas[2]) * scale;
return "vec3(" + std::to_string(r) + "," + std::to_string(g) + "," +
std::to_string(b) + ")";
};
auto density_layer =
[length_unit_in_meters](const DensityProfileLayer& layer) {
return "DensityProfileLayer(" +
std::to_string(layer.width / length_unit_in_meters) + "," +
std::to_string(layer.exp_term) + "," +
std::to_string(layer.exp_scale * length_unit_in_meters) + "," +
std::to_string(layer.linear_term * length_unit_in_meters) + "," +
std::to_string(layer.constant_term) + ")";
};
auto density_profile =
[density_layer](std::vector<DensityProfileLayer> layers) {
constexpr int kLayerCount = 2;
while (layers.size() < kLayerCount) {
layers.insert(layers.begin(), DensityProfileLayer());
}
std::string result = "DensityProfile(DensityProfileLayer[" +
std::to_string(kLayerCount) + "](";
for (int i = 0; i < kLayerCount; ++i) {
result += density_layer(layers[i]);
result += i < kLayerCount - 1 ? "," : "))";
}
return result;
};
// Compute the values for the SKY_RADIANCE_TO_LUMINANCE constant. In theory
// this should be 1 in precomputed illuminance mode (because the precomputed
// textures already contain illuminance values). In practice, however, storing
// true illuminance values in half precision textures yields artefacts
// (because the values are too large), so we store illuminance values divided
// by MAX_LUMINOUS_EFFICACY instead. This is why, in precomputed illuminance
// mode, we set SKY_RADIANCE_TO_LUMINANCE to MAX_LUMINOUS_EFFICACY.
bool precompute_illuminance = num_precomputed_wavelengths > 3;
double sky_k_r, sky_k_g, sky_k_b;
if (precompute_illuminance) {
sky_k_r = sky_k_g = sky_k_b = MAX_LUMINOUS_EFFICACY;
} else {
ComputeSpectralRadianceToLuminanceFactors(wavelengths, solar_irradiance,
-3 /* lambda_power */, &sky_k_r, &sky_k_g, &sky_k_b);
}
// Compute the values for the SUN_RADIANCE_TO_LUMINANCE constant.
double sun_k_r, sun_k_g, sun_k_b;
ComputeSpectralRadianceToLuminanceFactors(wavelengths, solar_irradiance,
0 /* lambda_power */, &sun_k_r, &sun_k_g, &sun_k_b);
// A lambda that creates a GLSL header containing our atmosphere computation
// functions, specialized for the given atmosphere parameters and for the 3
// wavelengths in 'lambdas'.
glsl_header_factory_ = [=](const vec3& lambdas) {
return
"#version 330\n"
"#define IN(x) const in x\n"
"#define OUT(x) out x\n"
"#define TEMPLATE(x)\n"
"#define TEMPLATE_ARGUMENT(x)\n"
"#define assert(x)\n"
"const int TRANSMITTANCE_TEXTURE_WIDTH = " +
std::to_string(TRANSMITTANCE_TEXTURE_WIDTH) + ";\n" +
"const int TRANSMITTANCE_TEXTURE_HEIGHT = " +
std::to_string(TRANSMITTANCE_TEXTURE_HEIGHT) + ";\n" +
"const int SCATTERING_TEXTURE_R_SIZE = " +
std::to_string(SCATTERING_TEXTURE_R_SIZE) + ";\n" +
"const int SCATTERING_TEXTURE_MU_SIZE = " +
std::to_string(SCATTERING_TEXTURE_MU_SIZE) + ";\n" +
"const int SCATTERING_TEXTURE_MU_S_SIZE = " +
std::to_string(SCATTERING_TEXTURE_MU_S_SIZE) + ";\n" +
"const int SCATTERING_TEXTURE_NU_SIZE = " +
std::to_string(SCATTERING_TEXTURE_NU_SIZE) + ";\n" +
"const int IRRADIANCE_TEXTURE_WIDTH = " +
std::to_string(IRRADIANCE_TEXTURE_WIDTH) + ";\n" +
"const int IRRADIANCE_TEXTURE_HEIGHT = " +
std::to_string(IRRADIANCE_TEXTURE_HEIGHT) + ";\n" +
(combine_scattering_textures ?
"#define COMBINED_SCATTERING_TEXTURES\n" : "") +
definitions_glsl +
"const AtmosphereParameters ATMOSPHERE = AtmosphereParameters(\n" +
to_string(solar_irradiance, lambdas, 1.0) + ",\n" +
std::to_string(sun_angular_radius) + ",\n" +
std::to_string(bottom_radius / length_unit_in_meters) + ",\n" +
std::to_string(top_radius / length_unit_in_meters) + ",\n" +
density_profile(rayleigh_density) + ",\n" +
to_string(
rayleigh_scattering, lambdas, length_unit_in_meters) + ",\n" +
density_profile(mie_density) + ",\n" +
to_string(mie_scattering, lambdas, length_unit_in_meters) + ",\n" +
to_string(mie_extinction, lambdas, length_unit_in_meters) + ",\n" +
std::to_string(mie_phase_function_g) + ",\n" +
density_profile(absorption_density) + ",\n" +
to_string(
absorption_extinction, lambdas, length_unit_in_meters) + ",\n" +
to_string(ground_albedo, lambdas, 1.0) + ",\n" +
std::to_string(cos(max_sun_zenith_angle)) + ");\n" +
"const vec3 SKY_SPECTRAL_RADIANCE_TO_LUMINANCE = vec3(" +
std::to_string(sky_k_r) + "," +
std::to_string(sky_k_g) + "," +
std::to_string(sky_k_b) + ");\n" +
"const vec3 SUN_SPECTRAL_RADIANCE_TO_LUMINANCE = vec3(" +
std::to_string(sun_k_r) + "," +
std::to_string(sun_k_g) + "," +
std::to_string(sun_k_b) + ");\n" +
functions_glsl;
};
// Allocate the precomputed textures, but don't precompute them yet.
transmittance_texture_ = NewTexture2d(
TRANSMITTANCE_TEXTURE_WIDTH, TRANSMITTANCE_TEXTURE_HEIGHT);
scattering_texture_ = NewTexture3d(
SCATTERING_TEXTURE_WIDTH,
SCATTERING_TEXTURE_HEIGHT,
SCATTERING_TEXTURE_DEPTH,
combine_scattering_textures || !rgb_format_supported_ ? GL_RGBA : GL_RGB,
half_precision);
if (combine_scattering_textures) {
optional_single_mie_scattering_texture_ = 0;
} else {
optional_single_mie_scattering_texture_ = NewTexture3d(
SCATTERING_TEXTURE_WIDTH,
SCATTERING_TEXTURE_HEIGHT,
SCATTERING_TEXTURE_DEPTH,
rgb_format_supported_ ? GL_RGB : GL_RGBA,
half_precision);
}
irradiance_texture_ = NewTexture2d(
IRRADIANCE_TEXTURE_WIDTH, IRRADIANCE_TEXTURE_HEIGHT);
// Create and compile the shader providing our API.
std::string shader =
glsl_header_factory_({kLambdaR, kLambdaG, kLambdaB}) +
(precompute_illuminance ? "" : "#define RADIANCE_API_ENABLED\n") +
kAtmosphereShader;
const char* source = shader.c_str();
atmosphere_shader_ = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(atmosphere_shader_, 1, &source, NULL);
glCompileShader(atmosphere_shader_);
// Create a full screen quad vertex array and vertex buffer objects.
glGenVertexArrays(1, &full_screen_quad_vao_);
glBindVertexArray(full_screen_quad_vao_);
glGenBuffers(1, &full_screen_quad_vbo_);
glBindBuffer(GL_ARRAY_BUFFER, full_screen_quad_vbo_);
const GLfloat vertices[] = {
-1.0, -1.0,
+1.0, -1.0,
-1.0, +1.0,
+1.0, +1.0,
};
constexpr int kCoordsPerVertex = 2;
glBufferData(GL_ARRAY_BUFFER, sizeof vertices, vertices, GL_STATIC_DRAW);
constexpr GLuint kAttribIndex = 0;
glVertexAttribPointer(kAttribIndex, kCoordsPerVertex, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(kAttribIndex);
glBindVertexArray(0);
}
The destructor is trivial:
Model::~Model() {
glDeleteBuffers(1, &full_screen_quad_vbo_);
glDeleteVertexArrays(1, &full_screen_quad_vao_);
glDeleteTextures(1, &transmittance_texture_);
glDeleteTextures(1, &scattering_texture_);
if (optional_single_mie_scattering_texture_ != 0) {
glDeleteTextures(1, &optional_single_mie_scattering_texture_);
}
glDeleteTextures(1, &irradiance_texture_);
glDeleteShader(atmosphere_shader_);
}
The Init method precomputes the atmosphere textures. It first allocates the
temporary resources it needs, then calls Precompute to do the
actual precomputations, and finally destroys the temporary resources.
Note that there are two precomputation modes here, depending on whether we want to store precomputed irradiance or illuminance values:
Precompute with the 3 wavelengths for which we want to precompute
irradiance, namely kLambdaR, kLambdaG,
kLambdaB (with the identity matrix for
luminance_from_radiance, since we don't want any conversion from
radiance to luminance)num_precomputed_wavelengths_, and then integrate the results,
multiplied with the 3 CIE xyz color matching functions and the XYZ to sRGB
matrix to get sRGB illuminance values.
A naive solution would be to allocate temporary textures for the intermediate irradiance results, then perform the integration from irradiance to illuminance and store the result in the final precomputed texture. In pseudo-code (and assuming one wavelength per texture instead of 3):
create n temporary irradiance textures
for each wavelength lambda in the n wavelengths:
precompute irradiance at lambda into one of the temporary textures
initializes the final illuminance texture with zeros
for each wavelength lambda in the n wavelengths:
accumulate in the final illuminance texture the product of the
precomputed irradiance at lambda (read from the temporary textures)
with the value of the 3 sRGB color matching functions at lambda (i.e.
the product of the XYZ to sRGB matrix with the CIE xyz color matching
functions).
However, this be would waste GPU memory. Instead, we can avoid allocating temporary irradiance textures, by merging the two above loops:
for each wavelength lambda in the n wavelengths:
accumulate in the final illuminance texture (or, for the first
iteration, set this texture to) the product of the precomputed
irradiance at lambda (computed on the fly) with the value of the 3
sRGB color matching functions at lambda.
This is the method we use below, with 3 wavelengths per iteration instead
of 1, using Precompute to compute 3 irradiances values per
iteration, and luminance_from_radiance to multiply 3 irradiances
with the values of the 3 sRGB color matching functions at 3 different
wavelengths (yielding a 3x3 matrix).
This yields the following implementation:
void Model::Init(unsigned int num_scattering_orders) {
// The precomputations require temporary textures, in particular to store the
// contribution of one scattering order, which is needed to compute the next
// order of scattering (the final precomputed textures store the sum of all
// the scattering orders). We allocate them here, and destroy them at the end
// of this method.
GLuint delta_irradiance_texture = NewTexture2d(
IRRADIANCE_TEXTURE_WIDTH, IRRADIANCE_TEXTURE_HEIGHT);
GLuint delta_rayleigh_scattering_texture = NewTexture3d(
SCATTERING_TEXTURE_WIDTH,
SCATTERING_TEXTURE_HEIGHT,
SCATTERING_TEXTURE_DEPTH,
rgb_format_supported_ ? GL_RGB : GL_RGBA,
half_precision_);
GLuint delta_mie_scattering_texture = NewTexture3d(
SCATTERING_TEXTURE_WIDTH,
SCATTERING_TEXTURE_HEIGHT,
SCATTERING_TEXTURE_DEPTH,
rgb_format_supported_ ? GL_RGB : GL_RGBA,
half_precision_);
GLuint delta_scattering_density_texture = NewTexture3d(
SCATTERING_TEXTURE_WIDTH,
SCATTERING_TEXTURE_HEIGHT,
SCATTERING_TEXTURE_DEPTH,
rgb_format_supported_ ? GL_RGB : GL_RGBA,
half_precision_);
// delta_multiple_scattering_texture is only needed to compute scattering
// order 3 or more, while delta_rayleigh_scattering_texture and
// delta_mie_scattering_texture are only needed to compute double scattering.
// Therefore, to save memory, we can store delta_rayleigh_scattering_texture
// and delta_multiple_scattering_texture in the same GPU texture.
GLuint delta_multiple_scattering_texture = delta_rayleigh_scattering_texture;
// The precomputations also require a temporary framebuffer object, created
// here (and destroyed at the end of this method).
GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
// The actual precomputations depend on whether we want to store precomputed
// irradiance or illuminance values.
if (num_precomputed_wavelengths_ <= 3) {
vec3 lambdas{kLambdaR, kLambdaG, kLambdaB};
mat3 luminance_from_radiance{1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0};
Precompute(fbo, delta_irradiance_texture, delta_rayleigh_scattering_texture,
delta_mie_scattering_texture, delta_scattering_density_texture,
delta_multiple_scattering_texture, lambdas, luminance_from_radiance,
false /* blend */, num_scattering_orders);
} else {
constexpr double kLambdaMin = 360.0;
constexpr double kLambdaMax = 830.0;
int num_iterations = (num_precomputed_wavelengths_ + 2) / 3;
double dlambda = (kLambdaMax - kLambdaMin) / (3 * num_iterations);
for (int i = 0; i < num_iterations; ++i) {
vec3 lambdas{
kLambdaMin + (3 * i + 0.5) * dlambda,
kLambdaMin + (3 * i + 1.5) * dlambda,
kLambdaMin + (3 * i + 2.5) * dlambda
};
auto coeff = [dlambda](double lambda, int component) {
// Note that we don't include MAX_LUMINOUS_EFFICACY here, to avoid
// artefacts due to too large values when using half precision on GPU.
// We add this term back in kAtmosphereShader, via
// SKY_SPECTRAL_RADIANCE_TO_LUMINANCE (see also the comments in the
// Model constructor).
double x = CieColorMatchingFunctionTableValue(lambda, 1);
double y = CieColorMatchingFunctionTableValue(lambda, 2);
double z = CieColorMatchingFunctionTableValue(lambda, 3);
return static_cast<float>((
XYZ_TO_SRGB[component * 3] * x +
XYZ_TO_SRGB[component * 3 + 1] * y +
XYZ_TO_SRGB[component * 3 + 2] * z) * dlambda);
};
mat3 luminance_from_radiance{
coeff(lambdas[0], 0), coeff(lambdas[1], 0), coeff(lambdas[2], 0),
coeff(lambdas[0], 1), coeff(lambdas[1], 1), coeff(lambdas[2], 1),
coeff(lambdas[0], 2), coeff(lambdas[1], 2), coeff(lambdas[2], 2)
};
Precompute(fbo, delta_irradiance_texture,
delta_rayleigh_scattering_texture, delta_mie_scattering_texture,
delta_scattering_density_texture, delta_multiple_scattering_texture,
lambdas, luminance_from_radiance, i > 0 /* blend */,
num_scattering_orders);
}
// After the above iterations, the transmittance texture contains the
// transmittance for the 3 wavelengths used at the last iteration. But we
// want the transmittance at kLambdaR, kLambdaG, kLambdaB instead, so we
// must recompute it here for these 3 wavelengths:
std::string header = glsl_header_factory_({kLambdaR, kLambdaG, kLambdaB});
Program compute_transmittance(
kVertexShader, header + kComputeTransmittanceShader);
glFramebufferTexture(
GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, transmittance_texture_, 0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glViewport(0, 0, TRANSMITTANCE_TEXTURE_WIDTH, TRANSMITTANCE_TEXTURE_HEIGHT);
compute_transmittance.Use();
DrawQuad({}, full_screen_quad_vao_);
}
// Delete the temporary resources allocated at the begining of this method.
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDeleteFramebuffers(1, &fbo);
glDeleteTextures(1, &delta_scattering_density_texture);
glDeleteTextures(1, &delta_mie_scattering_texture);
glDeleteTextures(1, &delta_rayleigh_scattering_texture);
glDeleteTextures(1, &delta_irradiance_texture);
assert(glGetError() == 0);
}
The SetProgramUniforms method is straightforward: it simply
binds the precomputed textures to the specified texture units, and then sets
the corresponding uniforms in the user provided program to the index of these
texture units.
void Model::SetProgramUniforms(
GLuint program,
GLuint transmittance_texture_unit,
GLuint scattering_texture_unit,
GLuint irradiance_texture_unit,
GLuint single_mie_scattering_texture_unit) const {
glActiveTexture(GL_TEXTURE0 + transmittance_texture_unit);
glBindTexture(GL_TEXTURE_2D, transmittance_texture_);
glUniform1i(glGetUniformLocation(program, "transmittance_texture"),
transmittance_texture_unit);
glActiveTexture(GL_TEXTURE0 + scattering_texture_unit);
glBindTexture(GL_TEXTURE_3D, scattering_texture_);
glUniform1i(glGetUniformLocation(program, "scattering_texture"),
scattering_texture_unit);
glActiveTexture(GL_TEXTURE0 + irradiance_texture_unit);
glBindTexture(GL_TEXTURE_2D, irradiance_texture_);
glUniform1i(glGetUniformLocation(program, "irradiance_texture"),
irradiance_texture_unit);
if (optional_single_mie_scattering_texture_ != 0) {
glActiveTexture(GL_TEXTURE0 + single_mie_scattering_texture_unit);
glBindTexture(GL_TEXTURE_3D, optional_single_mie_scattering_texture_);
glUniform1i(glGetUniformLocation(program, "single_mie_scattering_texture"),
single_mie_scattering_texture_unit);
}
}
The utility method ConvertSpectrumToLinearSrgb is implemented
with a simple numerical integration of the given function, times the CIE color
matching funtions (with an integration step of 1nm), followed by a matrix
multiplication:
void Model::ConvertSpectrumToLinearSrgb(
const std::vector<double>& wavelengths,
const std::vector<double>& spectrum,
double* r, double* g, double* b) {
double x = 0.0;
double y = 0.0;
double z = 0.0;
const int dlambda = 1;
for (int lambda = kLambdaMin; lambda < kLambdaMax; lambda += dlambda) {
double value = Interpolate(wavelengths, spectrum, lambda);
x += CieColorMatchingFunctionTableValue(lambda, 1) * value;
y += CieColorMatchingFunctionTableValue(lambda, 2) * value;
z += CieColorMatchingFunctionTableValue(lambda, 3) * value;
}
*r = MAX_LUMINOUS_EFFICACY *
(XYZ_TO_SRGB[0] * x + XYZ_TO_SRGB[1] * y + XYZ_TO_SRGB[2] * z) * dlambda;
*g = MAX_LUMINOUS_EFFICACY *
(XYZ_TO_SRGB[3] * x + XYZ_TO_SRGB[4] * y + XYZ_TO_SRGB[5] * z) * dlambda;
*b = MAX_LUMINOUS_EFFICACY *
(XYZ_TO_SRGB[6] * x + XYZ_TO_SRGB[7] * y + XYZ_TO_SRGB[8] * z) * dlambda;
}
Finally, we provide the actual implementation of the precomputation algorithm described in Algorithm 4.1 of our paper. Each step is explained by the inline comments below.
void Model::Precompute(
GLuint fbo,
GLuint delta_irradiance_texture,
GLuint delta_rayleigh_scattering_texture,
GLuint delta_mie_scattering_texture,
GLuint delta_scattering_density_texture,
GLuint delta_multiple_scattering_texture,
const vec3& lambdas,
const mat3& luminance_from_radiance,
bool blend,
unsigned int num_scattering_orders) {
// The precomputations require specific GLSL programs, for each precomputation
// step. We create and compile them here (they are automatically destroyed
// when this method returns, via the Program destructor).
std::string header = glsl_header_factory_(lambdas);
Program compute_transmittance(
kVertexShader, header + kComputeTransmittanceShader);
Program compute_direct_irradiance(
kVertexShader, header + kComputeDirectIrradianceShader);
Program compute_single_scattering(kVertexShader, kGeometryShader,
header + kComputeSingleScatteringShader);
Program compute_scattering_density(kVertexShader, kGeometryShader,
header + kComputeScatteringDensityShader);
Program compute_indirect_irradiance(
kVertexShader, header + kComputeIndirectIrradianceShader);
Program compute_multiple_scattering(kVertexShader, kGeometryShader,
header + kComputeMultipleScatteringShader);
const GLuint kDrawBuffers[4] = {
GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3
};
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
// Compute the transmittance, and store it in transmittance_texture_.
glFramebufferTexture(
GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, transmittance_texture_, 0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glViewport(0, 0, TRANSMITTANCE_TEXTURE_WIDTH, TRANSMITTANCE_TEXTURE_HEIGHT);
compute_transmittance.Use();
DrawQuad({}, full_screen_quad_vao_);
// Compute the direct irradiance, store it in delta_irradiance_texture and,
// depending on 'blend', either initialize irradiance_texture_ with zeros or
// leave it unchanged (we don't want the direct irradiance in
// irradiance_texture_, but only the irradiance from the sky).
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
delta_irradiance_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
irradiance_texture_, 0);
glDrawBuffers(2, kDrawBuffers);
glViewport(0, 0, IRRADIANCE_TEXTURE_WIDTH, IRRADIANCE_TEXTURE_HEIGHT);
compute_direct_irradiance.Use();
compute_direct_irradiance.BindTexture2d(
"transmittance_texture", transmittance_texture_, 0);
DrawQuad({false, blend}, full_screen_quad_vao_);
// Compute the rayleigh and mie single scattering, store them in
// delta_rayleigh_scattering_texture and delta_mie_scattering_texture, and
// either store them or accumulate them in scattering_texture_ and
// optional_single_mie_scattering_texture_.
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
delta_rayleigh_scattering_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
delta_mie_scattering_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2,
scattering_texture_, 0);
if (optional_single_mie_scattering_texture_ != 0) {
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3,
optional_single_mie_scattering_texture_, 0);
glDrawBuffers(4, kDrawBuffers);
} else {
glDrawBuffers(3, kDrawBuffers);
}
glViewport(0, 0, SCATTERING_TEXTURE_WIDTH, SCATTERING_TEXTURE_HEIGHT);
compute_single_scattering.Use();
compute_single_scattering.BindMat3(
"luminance_from_radiance", luminance_from_radiance);
compute_single_scattering.BindTexture2d(
"transmittance_texture", transmittance_texture_, 0);
for (unsigned int layer = 0; layer < SCATTERING_TEXTURE_DEPTH; ++layer) {
compute_single_scattering.BindInt("layer", layer);
DrawQuad({false, false, blend, blend}, full_screen_quad_vao_);
}
// Compute the 2nd, 3rd and 4th order of scattering, in sequence.
for (unsigned int scattering_order = 2;
scattering_order <= num_scattering_orders;
++scattering_order) {
// Compute the scattering density, and store it in
// delta_scattering_density_texture.
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
delta_scattering_density_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, 0, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, 0, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, 0, 0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glViewport(0, 0, SCATTERING_TEXTURE_WIDTH, SCATTERING_TEXTURE_HEIGHT);
compute_scattering_density.Use();
compute_scattering_density.BindTexture2d(
"transmittance_texture", transmittance_texture_, 0);
compute_scattering_density.BindTexture3d(
"single_rayleigh_scattering_texture",
delta_rayleigh_scattering_texture,
1);
compute_scattering_density.BindTexture3d(
"single_mie_scattering_texture", delta_mie_scattering_texture, 2);
compute_scattering_density.BindTexture3d(
"multiple_scattering_texture", delta_multiple_scattering_texture, 3);
compute_scattering_density.BindTexture2d(
"irradiance_texture", delta_irradiance_texture, 4);
compute_scattering_density.BindInt("scattering_order", scattering_order);
for (unsigned int layer = 0; layer < SCATTERING_TEXTURE_DEPTH; ++layer) {
compute_scattering_density.BindInt("layer", layer);
DrawQuad({}, full_screen_quad_vao_);
}
// Compute the indirect irradiance, store it in delta_irradiance_texture and
// accumulate it in irradiance_texture_.
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
delta_irradiance_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
irradiance_texture_, 0);
glDrawBuffers(2, kDrawBuffers);
glViewport(0, 0, IRRADIANCE_TEXTURE_WIDTH, IRRADIANCE_TEXTURE_HEIGHT);
compute_indirect_irradiance.Use();
compute_indirect_irradiance.BindMat3(
"luminance_from_radiance", luminance_from_radiance);
compute_indirect_irradiance.BindTexture3d(
"single_rayleigh_scattering_texture",
delta_rayleigh_scattering_texture,
0);
compute_indirect_irradiance.BindTexture3d(
"single_mie_scattering_texture", delta_mie_scattering_texture, 1);
compute_indirect_irradiance.BindTexture3d(
"multiple_scattering_texture", delta_multiple_scattering_texture, 2);
compute_indirect_irradiance.BindInt("scattering_order",
scattering_order - 1);
DrawQuad({false, true}, full_screen_quad_vao_);
// Compute the multiple scattering, store it in
// delta_multiple_scattering_texture, and accumulate it in
// scattering_texture_.
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
delta_multiple_scattering_texture, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
scattering_texture_, 0);
glDrawBuffers(2, kDrawBuffers);
glViewport(0, 0, SCATTERING_TEXTURE_WIDTH, SCATTERING_TEXTURE_HEIGHT);
compute_multiple_scattering.Use();
compute_multiple_scattering.BindMat3(
"luminance_from_radiance", luminance_from_radiance);
compute_multiple_scattering.BindTexture2d(
"transmittance_texture", transmittance_texture_, 0);
compute_multiple_scattering.BindTexture3d(
"scattering_density_texture", delta_scattering_density_texture, 1);
for (unsigned int layer = 0; layer < SCATTERING_TEXTURE_DEPTH; ++layer) {
compute_multiple_scattering.BindInt("layer", layer);
DrawQuad({false, true}, full_screen_quad_vao_);
}
}
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, 0, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, 0, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, 0, 0);
}
} // namespace atmosphere