/* * Copyright (C) 2023 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 "game/world.hpp" #include #include #include #include #include "game/commands/commands.hpp" #include "game/components/atmosphere-component.hpp" #include "game/components/blackbody-component.hpp" #include "game/components/celestial-body-component.hpp" #include "game/components/observer-component.hpp" #include "game/components/orbit-component.hpp" #include "game/components/terrain-component.hpp" #include "game/components/transform-component.hpp" #include "game/systems/astronomy-system.hpp" #include "game/systems/atmosphere-system.hpp" #include "game/systems/orbit-system.hpp" #include "game/systems/terrain-system.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace world { /// Loads an ephemeris. static void load_ephemeris(::game& ctx); /// Creates the fixed stars. static void create_stars(::game& ctx); /// Creates the Sun. static void create_sun(::game& ctx); /// Creates the Earth-Moon system. static void create_earth_moon_system(::game& ctx); /// Creates the Earth. static void create_earth(::game& ctx); /// Creates the Moon. static void create_moon(::game& ctx); void cosmogenesis(::game& ctx) { debug::log::trace("Generating cosmos..."); load_ephemeris(ctx); create_stars(ctx); create_sun(ctx); create_earth_moon_system(ctx); debug::log::trace("Generated cosmos"); } void create_observer(::game& ctx) { debug::log::trace("Creating observer..."); { // Create observer entity entity::id observer_eid = ctx.entity_registry->create(); ctx.entities["observer"] = observer_eid; // Construct observer component ::observer_component observer; // Set observer reference body if (auto it = ctx.entities.find("earth"); it != ctx.entities.end()) observer.reference_body_eid = it->second; else observer.reference_body_eid = entt::null; // Set observer location observer.elevation = 0.0; observer.latitude = 0.0; observer.longitude = 0.0; // Assign observer component to observer entity ctx.entity_registry->emplace<::observer_component>(observer_eid, observer); // Set atmosphere system active atmosphere ctx.atmosphere_system->set_active_atmosphere(observer.reference_body_eid); // Set astronomy system observer ctx.astronomy_system->set_observer(observer_eid); } debug::log::trace("Created observer"); } void set_location(::game& ctx, double elevation, double latitude, double longitude) { if (auto it = ctx.entities.find("observer"); it != ctx.entities.end()) { entity::id observer_eid = it->second; if (ctx.entity_registry->valid(observer_eid) && ctx.entity_registry->all_of<::observer_component>(observer_eid)) { // Update observer location ctx.entity_registry->patch<::observer_component> ( observer_eid, [&](auto& component) { component.elevation = elevation; component.latitude = latitude; component.longitude = longitude; } ); } } } void set_time(::game& ctx, double t) { try { ctx.astronomy_system->set_time(t); ctx.orbit_system->set_time(t); debug::log::info("Set time to UT1 {}", t); } catch (const std::exception& e) { debug::log::error("Failed to set time to UT1 {}: {}", t, e.what()); } } void set_time(::game& ctx, int year, int month, int day, int hour, int minute, double second) { double longitude = 0.0; // Get longitude of observer if (auto it = ctx.entities.find("observer"); it != ctx.entities.end()) { entity::id observer_eid = it->second; if (ctx.entity_registry->valid(observer_eid)) { const auto observer = ctx.entity_registry->try_get<::observer_component>(observer_eid); if (observer) longitude = observer->longitude; } } // Calculate UTC offset at longitude const double utc_offset = physics::time::utc::offset(longitude); // Convert time from Gregorian to UT1 const double t = physics::time::gregorian::to_ut1(year, month, day, hour, minute, second, utc_offset); set_time(ctx, t); } void set_time_scale(::game& ctx, double scale) { // Convert time scale from seconds to days const double astronomical_scale = scale / physics::time::seconds_per_day; ctx.orbit_system->set_time_scale(astronomical_scale); ctx.astronomy_system->set_time_scale(astronomical_scale); } void load_ephemeris(::game& ctx) { ctx.orbit_system->set_ephemeris(ctx.resource_manager->load>("de421.eph")); } void create_stars(::game& ctx) { debug::log::trace("Generating fixed stars..."); // Load star catalog auto star_catalog = ctx.resource_manager->load("hipparcos-7.tsv"); // Allocate star catalog vertex data std::size_t star_count = 0; if (star_catalog->rows.size() > 0) star_count = star_catalog->rows.size() - 1; std::size_t star_vertex_size = 7; std::size_t star_vertex_stride = star_vertex_size * sizeof(float); std::vector star_vertex_data(star_count * star_vertex_size); float* star_vertex = star_vertex_data.data(); // Init starlight illuminance double3 starlight_illuminance = {0, 0, 0}; // Build star catalog vertex data for (std::size_t i = 1; i < star_catalog->rows.size(); ++i) { const auto& row = star_catalog->rows[i]; // Parse star catalog item float ra = 0.0; float dec = 0.0; float vmag = 0.0; float bv = 0.0; try { ra = std::stof(row[1]); dec = std::stof(row[2]); vmag = std::stof(row[3]); bv = std::stof(row[4]); } catch (const std::exception&) { debug::log::warning("Invalid star catalog item on row {}", i); continue; } // Convert right ascension and declination from degrees to radians ra = math::wrap_radians(math::radians(ra)); dec = math::wrap_radians(math::radians(dec)); // Convert ICRF coordinates from spherical to Cartesian float3 position = physics::orbit::frame::bci::cartesian(float3{1.0f, dec, ra}); // Convert color index to color temperature float cct = color::index::bv_to_cct(bv); // Calculate XYZ color from color temperature float3 color_xyz = color::cct::to_xyz(cct); // Transform XYZ color to ACEScg colorspace float3 color_acescg = color::aces::ap1.from_xyz * color_xyz; // Convert apparent magnitude to brightness factor relative to a 0th magnitude star float brightness = physics::light::vmag::to_brightness(vmag); // Build vertex *(star_vertex++) = position.x(); *(star_vertex++) = position.y(); *(star_vertex++) = position.z(); *(star_vertex++) = color_acescg.x(); *(star_vertex++) = color_acescg.y(); *(star_vertex++) = color_acescg.z(); *(star_vertex++) = brightness; // Calculate spectral illuminance double3 illuminance = double3(color_acescg * physics::light::vmag::to_illuminance(vmag)); // Add spectral illuminance to total starlight illuminance starlight_illuminance += illuminance; } // Allocate stars model std::shared_ptr stars_model = std::make_shared(); // Get model VBO and VAO auto& vbo = stars_model->get_vertex_buffer(); auto& vao = stars_model->get_vertex_array(); // Resize model VBO and upload vertex data vbo->resize(star_vertex_data.size(), std::as_bytes(std::span{star_vertex_data})); std::size_t attribute_offset = 0; // Define position vertex attribute gl::vertex_attribute position_attribute; position_attribute.buffer = vbo.get(); position_attribute.offset = attribute_offset; position_attribute.stride = star_vertex_stride; position_attribute.type = gl::vertex_attribute_type::float_32; position_attribute.components = 3; attribute_offset += position_attribute.components * sizeof(float); // Define color vertex attribute gl::vertex_attribute color_attribute; color_attribute.buffer = vbo.get(); color_attribute.offset = attribute_offset; color_attribute.stride = star_vertex_stride; color_attribute.type = gl::vertex_attribute_type::float_32; color_attribute.components = 4; //attribute_offset += color_attribute.components * sizeof(float); // Bind vertex attributes to VAO vao->bind(render::vertex_attribute::position, position_attribute); vao->bind(render::vertex_attribute::color, color_attribute); // Load star material std::shared_ptr star_material = ctx.resource_manager->load("fixed-star.mtl"); // Create model group stars_model->get_groups().resize(1); render::model_group& stars_model_group = stars_model->get_groups().back(); stars_model_group.id = "stars"; stars_model_group.material = star_material; stars_model_group.drawing_mode = gl::drawing_mode::points; stars_model_group.start_index = 0; stars_model_group.index_count = static_cast(star_count); // Pass stars model to sky pass ctx.sky_pass->set_stars_model(stars_model); // Pass starlight illuminance to astronomy system ctx.astronomy_system->set_starlight_illuminance(starlight_illuminance); debug::log::trace("Generated fixed stars"); } void create_sun(::game& ctx) { debug::log::trace("Generating Sun..."); { // Create sun entity auto sun_archetype = ctx.resource_manager->load("sun.ent"); entity::id sun_eid = sun_archetype->create(*ctx.entity_registry); ctx.entities["sun"] = sun_eid; // Create sun directional light scene object ctx.sun_light = std::make_unique(); ctx.sun_light->set_color({0, 0, 0}); ctx.sun_light->set_shadow_caster(true); ctx.sun_light->set_shadow_framebuffer(ctx.shadow_map_framebuffer.get()); ctx.sun_light->set_shadow_bias(0.005f); ctx.sun_light->set_shadow_cascade_count(4); ctx.sun_light->set_shadow_cascade_coverage(0.15f); ctx.sun_light->set_shadow_cascade_distribution(0.8f); ctx.sun_light->update_tweens(); // Create sky ambient light scene object ctx.sky_light = std::make_unique(); ctx.sky_light->set_color({0, 0, 0}); ctx.sky_light->update_tweens(); // Create bounce directional light scene object ctx.bounce_light = std::make_unique(); ctx.bounce_light->set_color({0, 0, 0}); ctx.bounce_light->look_at({0, 0, 0}, {0, 1, 0}, {1, 0, 0}); ctx.bounce_light->update_tweens(); // Add sun light scene objects to surface scene ctx.surface_scene->add_object(ctx.sun_light.get()); ctx.surface_scene->add_object(ctx.sky_light.get()); //ctx.surface_scene->add_object(ctx.bounce_light); // Pass direct sun light scene object to shadow map pass and astronomy system ctx.astronomy_system->set_sun_light(ctx.sun_light.get()); ctx.astronomy_system->set_sky_light(ctx.sky_light.get()); ctx.astronomy_system->set_bounce_light(ctx.bounce_light.get()); } debug::log::trace("Generated Sun"); } void create_earth_moon_system(::game& ctx) { debug::log::trace("Generating Earth-Moon system..."); { // Create Earth-Moon barycenter entity auto em_bary_archetype = ctx.resource_manager->load("em-bary.ent"); entity::id em_bary_eid = em_bary_archetype->create(*ctx.entity_registry); ctx.entities["em_bary"] = em_bary_eid; // Create Earth create_earth(ctx); // Create Moon create_moon(ctx); } debug::log::trace("Generated Earth-Moon system"); } void create_earth(::game& ctx) { debug::log::trace("Generating Earth..."); { // Create earth entity auto earth_archetype = ctx.resource_manager->load("earth.ent"); entity::id earth_eid = earth_archetype->create(*ctx.entity_registry); ctx.entities["earth"] = earth_eid; // Assign orbital parent ctx.entity_registry->get<::orbit_component>(earth_eid).parent = ctx.entities["em_bary"]; } debug::log::trace("Generated Earth"); } void create_moon(::game& ctx) { debug::log::trace("Generating Moon..."); { // Create lunar entity auto moon_archetype = ctx.resource_manager->load("moon.ent"); entity::id moon_eid = moon_archetype->create(*ctx.entity_registry); ctx.entities["moon"] = moon_eid; // Assign orbital parent ctx.entity_registry->get<::orbit_component>(moon_eid).parent = ctx.entities["em_bary"]; // Pass moon model to sky pass ctx.sky_pass->set_moon_model(ctx.resource_manager->load("moon.mdl")); // Create moon directional light scene object ctx.moon_light = std::make_unique(); ctx.moon_light->set_color({0, 0, 0}); ctx.moon_light->update_tweens(); // Add moon light scene objects to surface scene ctx.surface_scene->add_object(ctx.moon_light.get()); // Pass moon light scene object to astronomy system ctx.astronomy_system->set_moon_light(ctx.moon_light.get()); } debug::log::trace("Generated Moon"); } void enter_ecoregion(::game& ctx, const ecoregion& ecoregion) { /* image img; img.format(1, 4); img.resize(2048, 2048); auto width = img.get_width(); auto height = img.get_height(); unsigned char* pixels = (unsigned char*)img.data(); const float frequency = 400.0f; float scale_x = 1.0f / static_cast(width - 1) * frequency; float scale_y = 1.0f / static_cast(height - 1) * frequency; std::for_each ( std::execution::par_unseq, img.begin>(), img.end>(), [pixels, width, height, scale_x, scale_y, frequency](auto& pixel) { const std::size_t i = &pixel - (math::vector*)pixels; const std::size_t y = i / width; const std::size_t x = i % width; const float2 position = { static_cast(x) * scale_x, static_cast(y) * scale_y }; const auto [ f1_sqr_distance, f1_displacement, f1_id ] = math::noise::voronoi::f1(position, 1.0f, {frequency, frequency}); const float f1_distance = std::sqrt(f1_sqr_distance); const float2 uv = (position + f1_displacement) / frequency; pixel = { static_cast(std::min(255.0f, f1_distance * 255.0f)), static_cast(std::min(255.0f, uv[0] * 255.0f)), static_cast(std::min(255.0f, uv[1] * 255.0f)), static_cast(f1_id % 256) }; } ); stbi_flip_vertically_on_write(1); stbi_write_tga((ctx.screenshots_path / "voronoi-f1-400-nc8-2k.tga").string().c_str(), img.get_width(), img.get_height(), img.get_channel_count(), img.data()); */ debug::log::trace("Entering ecoregion {}...", ecoregion.name); { // Set active ecoregion ctx.active_ecoregion = &ecoregion; // Set location ::world::set_location(ctx, ecoregion.elevation, ecoregion.latitude, ecoregion.longitude); // Setup sky ctx.sky_pass->set_sky_model(ctx.resource_manager->load("celestial-hemisphere.mdl")); auto terrestrial_hemisphere_model = ctx.resource_manager->load("terrestrial-hemisphere.mdl"); terrestrial_hemisphere_model->get_groups().front().material = ecoregion.horizon_material; ctx.ground_pass->set_ground_model(terrestrial_hemisphere_model); // Setup terrain ctx.terrain_system->set_patch_material(ecoregion.terrain_material); ctx.terrain_system->set_elevation_function ( [](float x, float z) -> float { const float2 position = float2{x, z}; const std::size_t octaves = 3; const float lacunarity = 1.5f; const float gain = 0.5f; const float fbm = math::noise::fbm ( position * 0.005f, octaves, lacunarity, gain ); float y = fbm * 4.0f; return y; } ); ctx.astronomy_system->set_bounce_albedo(double3(ecoregion.terrain_albedo)); } debug::log::trace("Entered ecoregion {}", ecoregion.name); } } // namespace world