/*
* Copyright (C) 2021 Christopher J. Howard
*
* This file is part of Antkeeper source code.
*
* Antkeeper source code is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Antkeeper source code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Antkeeper source code. If not, see .
*/
#include "entity/systems/astronomy.hpp"
#include "astro/apparent-size.hpp"
#include "entity/components/blackbody.hpp"
#include "entity/components/transform.hpp"
#include "entity/components/diffuse-reflector.hpp"
#include "geom/intersection.hpp"
#include "geom/cartesian.hpp"
#include "color/color.hpp"
#include "physics/orbit/orbit.hpp"
#include "physics/time/ut1.hpp"
#include "physics/light/photometry.hpp"
#include "physics/light/luminosity.hpp"
#include "physics/light/refraction.hpp"
#include "physics/atmosphere.hpp"
#include "geom/cartesian.hpp"
#include "astro/apparent-size.hpp"
#include "geom/solid-angle.hpp"
#include "math/polynomial.hpp"
#include
namespace entity {
namespace system {
template
math::vector3 transmittance(T depth_r, T depth_m, T depth_o, const math::vector3& beta_r, const math::vector3& beta_m)
{
math::vector3 transmittance_r = beta_r * depth_r;
math::vector3 transmittance_m = beta_m * 1.1 * depth_m;
math::vector3 transmittance_o = {0, 0, 0};
math::vector3 t = transmittance_r + transmittance_m + transmittance_o;
t.x = std::exp(-t.x);
t.y = std::exp(-t.y);
t.z = std::exp(-t.z);
return t;
}
astronomy::astronomy(entity::registry& registry):
updatable(registry),
time(0.0),
time_scale(1.0),
reference_entity(entt::null),
observer_location{0, 0, 0},
sun_light(nullptr),
sky_light(nullptr),
moon_light(nullptr),
camera(nullptr),
sky_pass(nullptr),
exposure_offset(0.0),
starlight_illuminance(0.0)
{
// Construct transformation which transforms coordinates from ENU to EUS
enu_to_eus = math::transformation::se3
{
{0, 0, 0},
math::quaternion::rotate_x(-math::half_pi)
};
registry.on_construct().connect<&astronomy::on_celestial_body_construct>(this);
registry.on_replace().connect<&astronomy::on_celestial_body_replace>(this);
}
astronomy::~astronomy()
{
registry.on_construct().disconnect<&astronomy::on_celestial_body_construct>(this);
registry.on_replace().disconnect<&astronomy::on_celestial_body_replace>(this);
}
void astronomy::update(double t, double dt)
{
double total_illuminance = 0.0;
double sky_light_illuminance = 0.0;
// Add scaled timestep to current time
set_time(time + dt * time_scale);
// Abort if no reference body
if (reference_entity == entt::null)
return;
// Abort if either reference body or orbit have not been set
if (!registry.has(reference_entity) || !registry.has(reference_entity))
return;
const entity::component::orbit& reference_orbit = registry.get(reference_entity);
const entity::component::celestial_body& reference_body = registry.get(reference_entity);
math::transformation::se3 icrf_to_bci{{-reference_orbit.position}, math::quaternion::identity};
const double days_from_epoch = time;
const double centuries_from_epoch = days_from_epoch / 36525.0;
// Evaluate reference body orientation polynomials
const double reference_body_pole_ra = math::polynomial::horner(reference_body.pole_ra.begin(), reference_body.pole_ra.end(), centuries_from_epoch);
const double reference_body_pole_dec = math::polynomial::horner(reference_body.pole_dec.begin(), reference_body.pole_dec.end(), centuries_from_epoch);
const double reference_body_prime_meridian = math::polynomial::horner(reference_body.prime_meridian.begin(), reference_body.prime_meridian.end(), days_from_epoch);
// Construct transformation from the ICRF frame to the reference body BCBF frame
icrf_to_bcbf = physics::orbit::frame::bci::to_bcbf
(
reference_body_pole_ra,
reference_body_pole_dec,
reference_body_prime_meridian
);
icrf_to_bcbf.t = icrf_to_bcbf.r * -reference_orbit.position;
icrf_to_enu = icrf_to_bcbf * bcbf_to_enu;
icrf_to_eus = icrf_to_enu * enu_to_eus;
// Set the transform component translations of orbiting bodies to their topocentric positions
registry.view().each(
[&](entity::id entity_id, const auto& body, const auto& orbit, auto& transform)
{
// Skip reference entity
if (entity_id == this->reference_entity)
return;
// Transform orbital Cartesian position (r) from the ICRF frame to the EUS frame
const double3 r_eus = icrf_to_eus * orbit.position;
// Evaluate body orientation polynomials
const double body_pole_ra = math::polynomial::horner(body.pole_ra.begin(), body.pole_ra.end(), centuries_from_epoch);
const double body_pole_dec = math::polynomial::horner(body.pole_dec.begin(), body.pole_dec.end(), centuries_from_epoch);
const double body_prime_meridian = math::polynomial::horner(body.prime_meridian.begin(), body.prime_meridian.end(), days_from_epoch);
// Determine body orientation in the ICRF frame
math::quaternion rotation_icrf = physics::orbit::frame::bcbf::to_bci
(
body_pole_ra,
body_pole_dec,
body_prime_meridian
).r;
// Transform body orientation from the ICRF frame to the EUS frame.
math::quaternion rotation_eus = math::normalize(icrf_to_eus.r * rotation_icrf);
// Update local transform
if (orbit.parent != entt::null)
{
transform.local.translation = math::normalize(math::type_cast(r_eus));
transform.local.rotation = math::type_cast(rotation_eus);
transform.local.scale = {1.0f, 1.0f, 1.0f};
}
/*
if (orbit.parent != entt::null)
{
// RA-DEC
const double3 r_bci = icrf_to_bci * orbit.position;
double3 r_bci_spherical = physics::orbit::frame::bci::spherical(r_bci);
if (r_bci_spherical.z < 0.0)
r_bci_spherical.z += math::two_pi;
const double dec = math::degrees(r_bci_spherical.y);
const double ra = math::degrees(r_bci_spherical.z);
// AZ-EL
const double3 r_enu = icrf_to_enu * orbit.position;
double3 r_enu_spherical = physics::orbit::frame::enu::spherical(r_enu);
if (r_enu_spherical.z < 0.0)
r_enu_spherical.z += math::two_pi;
const double el = math::degrees(r_enu_spherical.y);
const double az = math::degrees(r_enu_spherical.z);
std::cout << "t: " << this->time << "; ra: " << ra << "; dec: " << dec << std::endl;
std::cout << "t: " << this->time << "; az: " << az << "; el: " << el << std::endl;
}
*/
});
// Update blackbody lighting
registry.view().each(
[&](entity::id entity_id, const auto& body, const auto& orbit, const auto& blackbody)
{
// Calculate blackbody inertial basis
//double3 blackbody_forward_icrf = math::normalize(reference_orbit.icrf_position - orbit.icrf_position);
double3 blackbody_up_icrf = {0, 0, 1};
// Transform blackbody ICRF position and basis into EUS frame
double3 blackbody_position_eus = icrf_to_eus * orbit.position;
double3 blackbody_position_enu = icrf_to_enu * orbit.position;
double3 blackbody_forward_eus = math::normalize(-blackbody_position_eus);
double3 blackbody_up_eus = icrf_to_eus.r * blackbody_up_icrf;
// Calculate distance from observer to blackbody
double blackbody_distance = math::length(blackbody_position_eus) - body.radius;
// Calculate blackbody solid angle
const double blackbody_angular_radius = astro::angular_radius(body.radius, blackbody_distance);
const double blackbody_solid_angle = geom::solid_angle::cone(blackbody_angular_radius);
// Calculate blackbody illuminance
const double3 blackbody_illuminance = blackbody.luminance * blackbody_solid_angle;
// Init atmospheric transmittance
double3 atmospheric_transmittance = {1.0, 1.0, 1.0};
// Get atmosphere component of reference body (if any)
if (this->registry.has(reference_entity))
{
const entity::component::atmosphere& reference_atmosphere = registry.get(reference_entity);
// Altitude of observer in meters
geom::ray sample_ray;
sample_ray.origin = {0, reference_body.radius + observer_location[0], 0};
sample_ray.direction = math::normalize(blackbody_position_eus);
geom::sphere exosphere;
exosphere.center = {0, 0, 0};
exosphere.radius = reference_body.radius + reference_atmosphere.exosphere_altitude;
auto intersection_result = geom::ray_sphere_intersection(sample_ray, exosphere);
if (std::get<0>(intersection_result))
{
double3 sample_start = sample_ray.origin;
double3 sample_end = sample_ray.extrapolate(std::get<2>(intersection_result));
double optical_depth_r = physics::atmosphere::optical_depth(sample_start, sample_end, reference_body.radius, reference_atmosphere.rayleigh_scale_height, 32);
double optical_depth_k = physics::atmosphere::optical_depth(sample_start, sample_end, reference_body.radius, reference_atmosphere.mie_scale_height, 32);
double optical_depth_o = 0.0;
atmospheric_transmittance = transmittance(optical_depth_r, optical_depth_k, optical_depth_o, reference_atmosphere.rayleigh_scattering, reference_atmosphere.mie_scattering);
}
// Add airglow to sky light illuminance
sky_light_illuminance += reference_atmosphere.airglow;
}
// Blackbody illuminance transmitted through the atmosphere
const double3 transmitted_blackbody_illuminance = blackbody_illuminance * atmospheric_transmittance;
// Add atmosphere-transmitted blackbody illuminance to total illuminance
total_illuminance += (transmitted_blackbody_illuminance.x + transmitted_blackbody_illuminance.y + transmitted_blackbody_illuminance.z) / 3.0;
// Update sun light
if (sun_light != nullptr)
{
sun_light->set_translation(math::normalize(math::type_cast(blackbody_position_eus)));
sun_light->set_rotation
(
math::look_rotation
(
math::type_cast(blackbody_forward_eus),
math::type_cast(blackbody_up_eus)
)
);
sun_light->set_color(math::type_cast(transmitted_blackbody_illuminance));
}
// Update sky light
if (sky_light != nullptr)
{
// Calculate sky illuminance
double3 blackbody_position_enu_spherical = physics::orbit::frame::enu::spherical(blackbody_position_enu);
const double sky_illuminance = 25000.0 * std::max(0.0, std::sin(blackbody_position_enu_spherical.y));
// Add sky illuminance to sky light illuminance
sky_light_illuminance += sky_illuminance;
// Add starlight illuminance to sky light illuminance
sky_light_illuminance += starlight_illuminance;
// Add sky light illuminance to total illuminance
total_illuminance += sky_light_illuminance;
//std::cout << "sky light illum: " << sky_light_illuminance << std::endl;
// Update sky light
sky_light->set_color(float3{1.0f, 1.0f, 1.0f} * static_cast(sky_light_illuminance));
}
// Upload blackbody params to sky pass
if (this->sky_pass)
{
this->sky_pass->set_sun_position(math::type_cast(blackbody_position_eus));
this->sky_pass->set_sun_luminance(math::type_cast(blackbody.luminance));
this->sky_pass->set_sun_illuminance(math::type_cast(blackbody_illuminance));
this->sky_pass->set_sun_angular_radius(static_cast(blackbody_angular_radius));
}
const double3& blackbody_icrf_position = orbit.position;
// Update diffuse reflectors
this->registry.view().each(
[&](entity::id entity_id, const auto& reflector_body, const auto& reflector_orbit, const auto& reflector, const auto& transform)
{
// Calculate distance to blackbody and direction of incoming light
double3 blackbody_light_direction_icrf = reflector_orbit.position - blackbody_icrf_position;
double blackbody_distance = math::length(blackbody_light_direction_icrf);
blackbody_light_direction_icrf = blackbody_light_direction_icrf / blackbody_distance;
// Transform blackbody light direction from the ICRF frame to the EUS frame
double3 blackbody_light_direction_eus = icrf_to_eus.r * blackbody_light_direction_icrf;
// Calculate blackbody solid angle
const double blackbody_angular_radius = astro::angular_radius(body.radius, blackbody_distance);
const double blackbody_solid_angle = geom::solid_angle::cone(blackbody_angular_radius);
// Calculate blackbody illuminance
double3 view_direction_icrf = reflector_orbit.position - reference_orbit.position;
const double reflector_distance = math::length(view_direction_icrf);
view_direction_icrf = view_direction_icrf / reflector_distance;
const double3 sunlight_illuminance = blackbody.luminance * blackbody_solid_angle;
const double reflector_angular_radius = astro::angular_radius(reflector_body.radius, reflector_distance);
const double reflector_solid_angle = geom::solid_angle::cone(reflector_angular_radius);
const double reflector_phase_factor = dot(view_direction_icrf, blackbody_light_direction_icrf) * 0.5 + 0.5;
const double3 planet_luminance = (sunlight_illuminance * reference_body.albedo) / math::pi;
const double planet_angular_radius = astro::angular_radius(reference_body.radius, reflector_distance);
const double planet_solid_angle = geom::solid_angle::cone(planet_angular_radius);
const double planet_phase_factor = math::dot(-view_direction_icrf, math::normalize(reference_orbit.position - blackbody_icrf_position)) * 0.5 + 0.5;
const double3 planetlight_illuminance = planet_luminance * planet_solid_angle * planet_phase_factor;
double3 planetlight_direction_eus = math::normalize(icrf_to_eus.r * view_direction_icrf);
const double3 reflected_sunlight_luminance = (sunlight_illuminance * reflector.albedo) / math::pi;
const double3 reflected_sunlight_illuminance = reflected_sunlight_luminance * reflector_solid_angle * reflector_phase_factor;
const double3 reflected_planetlight_luminance = (planetlight_illuminance * reflector.albedo) / math::pi;
const double3 reflected_planetlight_illuminance = reflected_planetlight_luminance * reflector_solid_angle;
/*
std::cout << "reflected sunlight illuminance: " << reflected_sunlight_illuminance << std::endl;
std::cout << "planetlight illuminance: " << planetlight_illuminance << std::endl;
std::cout << "planet luminance: " << planet_luminance << std::endl;
std::cout << "reflected planetlight luminance: " << reflected_planetlight_luminance << std::endl;
std::cout << "reflected planetlight illuminance: " << reflected_planetlight_illuminance << std::endl;
std::cout << "reflector phase: " << reflector_phase_factor << std::endl;
std::cout << "planet phase: " << planet_phase_factor << std::endl;
*/
if (this->sky_pass)
{
this->sky_pass->set_moon_position(transform.local.translation);
this->sky_pass->set_moon_rotation(transform.local.rotation);
this->sky_pass->set_moon_angular_radius(static_cast(reflector_angular_radius));
this->sky_pass->set_moon_sunlight_direction(math::type_cast(blackbody_light_direction_eus));
this->sky_pass->set_moon_sunlight_illuminance(math::type_cast(sunlight_illuminance));
this->sky_pass->set_moon_planetlight_direction(math::type_cast(planetlight_direction_eus));
this->sky_pass->set_moon_planetlight_illuminance(math::type_cast(planetlight_illuminance));
}
if (this->moon_light)
{
float3 reflector_up_eus = math::type_cast(icrf_to_eus.r * double3{0, 0, 1});
double3 reflected_illuminance = reflected_sunlight_illuminance + reflected_planetlight_illuminance;
//reflected_illuminance *= std::max(0.0, std::sin(transform.local.translation.y));
total_illuminance += (reflected_illuminance.x + reflected_illuminance.y + reflected_illuminance.z) / 3.0;
this->moon_light->set_color(math::type_cast(reflected_illuminance));
this->moon_light->set_rotation
(
math::look_rotation
(
math::normalize(-transform.local.translation),
reflector_up_eus
)
);
}
/*
std::cout << "moon: sun solid angle: " << blackbody_solid_angle << std::endl;
std::cout << "moon: sun illuminance: " << blackbody_illuminance << std::endl;
std::cout << "moon: moon luminance: " << reflector_luminance << std::endl;
std::cout << "sun brightness: " << sun_brightness << std::endl;
std::cout << "vega brightness: " << vega_brightness << std::endl;
std::cout << "earth: moon distance: " << reflector_distance << std::endl;
std::cout << "earth: moon solid angle: " << reflector_solid_angle << std::endl;
std::cout << "earth: moon phase: " << reflector_phase << std::endl;
std::cout << "earth: moon phase angle: " << math::degrees(reflector_phase_angle) << std::endl;
std::cout << "earth: moon illum %: " << reflector_illumination_factor * 100.0 << std::endl;
std::cout << "earth: moon illuminance: " << reflector_illuminance << std::endl;
std::cout << "earth: moon phase-modulated illuminance: " << reflector_illuminance * reflector_illumination_factor << std::endl;
*/
});
});
// Update sky pass topocentric frame
if (sky_pass != nullptr)
{
// Upload topocentric frame to sky pass
sky_pass->set_icrf_to_eus
(
math::transformation::se3
{
math::type_cast(icrf_to_eus.t),
math::type_cast(icrf_to_eus.r)
}
);
// Upload observer altitude to sky pass
sky_pass->set_observer_altitude(observer_location[0]);
// Upload atmosphere params to sky pass
if (registry.has(reference_entity))
{
const entity::component::atmosphere& reference_atmosphere = registry.get(reference_entity);
sky_pass->set_scale_heights(reference_atmosphere.rayleigh_scale_height, reference_atmosphere.mie_scale_height);
sky_pass->set_scattering_coefficients(math::type_cast(reference_atmosphere.rayleigh_scattering), math::type_cast(reference_atmosphere.mie_scattering));
sky_pass->set_mie_anisotropy(reference_atmosphere.mie_anisotropy);
sky_pass->set_atmosphere_radii(reference_body.radius, reference_body.radius + reference_atmosphere.exosphere_altitude);
}
}
// Auto-exposure
if (camera)
{
const double calibration = 250.0;
const double ev100 = std::log2((total_illuminance * 100.0) / calibration);
//std::cout << "LUX: " << total_illuminance << std::endl;
//std::cout << "EV100: " << ev100 << std::endl;
//camera->set_exposure(exposure_offset);
}
}
void astronomy::set_time(double time)
{
this->time = time;
}
void astronomy::set_time_scale(double scale)
{
time_scale = scale;
}
void astronomy::set_reference_body(entity::id entity_id)
{
reference_entity = entity_id;
update_bcbf_to_enu();
}
void astronomy::set_observer_location(const double3& location)
{
observer_location = location;
update_bcbf_to_enu();
}
void astronomy::set_sun_light(scene::directional_light* light)
{
sun_light = light;
}
void astronomy::set_sky_light(scene::ambient_light* light)
{
sky_light = light;
}
void astronomy::set_moon_light(scene::directional_light* light)
{
moon_light = light;
}
void astronomy::set_camera(scene::camera* camera)
{
this->camera = camera;
}
void astronomy::set_exposure_offset(float offset)
{
exposure_offset = offset;
}
void astronomy::set_starlight_illuminance(double illuminance)
{
starlight_illuminance = illuminance;
}
void astronomy::set_sky_pass(::render::sky_pass* pass)
{
this->sky_pass = pass;
}
void astronomy::on_celestial_body_construct(entity::registry& registry, entity::id entity_id, entity::component::celestial_body& celestial_body)
{
if (entity_id == reference_entity)
update_bcbf_to_enu();
}
void astronomy::on_celestial_body_replace(entity::registry& registry, entity::id entity_id, entity::component::celestial_body& celestial_body)
{
if (entity_id == reference_entity)
update_bcbf_to_enu();
}
void astronomy::update_bcbf_to_enu()
{
double radial_distance = observer_location[0];
if (reference_entity)
{
if (registry.has(reference_entity))
radial_distance += registry.get(reference_entity).radius;
}
// Construct reference frame which transforms coordinates from a BCBF frame to a horizontal frame
bcbf_to_enu = physics::orbit::frame::bcbf::to_enu
(
radial_distance,
observer_location[1],
observer_location[2]
);
}
} // namespace system
} // namespace entity