Almost done with PBR SKY

Author: AEspinosaDev

include/engine/core/scene/skybox.h

@@ -20,14 +20,15 @@ namespace Core {
 Settings for Procedural Sky Rendering
 */
 struct SkySettings {
-    float          sunElevationDeg = 45.0f; // 0=horizon, 90=zenith
-    uint32_t       month           = 0;     // 0-11, January to December
-    float          altitude        = 0.5f;  // km
-    SkyAerosolType aerosol         = SkyAerosolType::URBAN;
-    Vec4           groundAlbedo    = Vec4(0.3);
-    uint32_t       resolution      = 1024;
-    bool           useForIBL       = true;
-    UpdateType     updateType      = UpdateType::PER_FRAME;
+    float          sunElevationDeg  = 45.0f; // 0=horizon, 90=zenith
+    uint32_t       month            = 0;     // 0-11, January to December
+    float          altitude         = 0.5f;  // km
+    SkyAerosolType aerosol          = SkyAerosolType::URBAN;
+    Vec4           groundAlbedo     = Vec4(0.3);
+    float          aerosolTurbidity = 1.0f;
+    uint32_t       resolution       = 512;
+    bool           useForIBL        = true;
+    UpdateType     updateType       = UpdateType::ON_DEMAND;
 };
 /*
 Skybox for rendering enviroments and IBL
@@ -114,11 +115,19 @@ class Skybox
         m_irradianceResolution = r;
         m_updateEnviroment     = true;
     }
+    inline void set_sky_type(EnviromentType type) {
+        m_updateEnviroment = true;
+        m_envType          = type;
+    }
+    inline EnviromentType get_sky_type() const {
+        return m_envType;
+    }
     /*
     Procedural Sky
     */
     inline void set_sky_settings(SkySettings settings) {
-        m_proceduralSky = settings;
+        m_proceduralSky    = settings;
+        m_updateEnviroment = true;
     }
     /*
     Procedural Sky

include/engine/tools/widgets.h

@@ -313,11 +313,13 @@ class ExplorerWidget : public Widget
     Core::Object3D* m_selectedObject{nullptr};
 
     bool m_showRendererSettings{false};
+    bool m_showSkySettings{false};
 
     virtual void render();
 
     void displayObject(Core::Object3D* const obj, int& counter);
     void displayRendererSettings();
+    void displaySkySettings();
 
   public:
     ExplorerWidget(Core::Scene* scene, Systems::BaseRenderer* renderer)

resources/shaders/env/panorama_converter.glsl

@@ -53,7 +53,12 @@ layout(location = 0) in vec2 otexCoord;
 
 layout(location = 0) out vec4 fragmentColor;
 
+layout(push_constant) uniform Settings {
+    int type;
+} settings;
+
 layout(set = 0, binding = 0) uniform sampler2D u_panorama;
+layout(set = 0, binding = 3) uniform sampler2D u_panoramaProcedural;
 
 vec3 uvToXYZ(int face, vec2 uv)
 {
@@ -90,7 +95,7 @@ vec3 panoramaToCubeMap(int face, vec2 texCoord)
 	vec3 direction = normalize(scan);
 	vec2 src = dirToUV(direction);
 
-	return  texture(u_panorama, src).rgb;
+	return  settings.type == 0 ? texture( u_panorama , src).rgb :  texture( u_panoramaProcedural , src).rgb;
 }
 
 

resources/shaders/env/sky_generation.glsl

@@ -18,13 +18,16 @@ void main() {
 
 layout(location = 0) in  vec2 v_uv;
 
+layout(push_constant) uniform Settings {
+    SkySettings sky;
+} settings;
 layout(set = 0, binding = 0) uniform sampler2D transmitanceLUT;
 
 layout(location = 0) out vec4 outColor;
 
 vec4 compute_inscattering(vec3 ray_origin, vec3 ray_dir, float t_d, out vec4 transmittance)
 {
-    vec3 sun_dir = get_sun_direction(5.0);
+    vec3 sun_dir = get_sun_direction(settings.sky.sunElevationDeg);
     float cos_theta = dot(-ray_dir, sun_dir);
 
     float molecular_phase = molecular_phase_function(cos_theta);
@@ -51,6 +54,8 @@ vec4 compute_inscattering(vec3 ray_origin, vec3 ray_dir, float t_d, out vec4 tra
         vec4 extinction;
         get_atmosphere_collision_coefficients(
             altitude,
+            settings.sky.month,
+            settings.sky.aerosolTurbidity,
             aerosol_absorption, aerosol_scattering,
             molecular_absorption, molecular_scattering,
             extinction);
@@ -59,7 +64,7 @@ vec4 compute_inscattering(vec3 ray_origin, vec3 ray_dir, float t_d, out vec4 tra
             transmitanceLUT, sample_cos_theta, normalized_altitude);
 
         vec4 ms = get_multiple_scattering(
-            transmitanceLUT, sample_cos_theta, normalized_altitude,
+            transmitanceLUT, settings.sky.groundAlbedo, sample_cos_theta, normalized_altitude,
             distance_to_earth_center);
 
         vec4 S = sun_spectral_irradiance *
@@ -93,12 +98,13 @@ void main()
                         cos(elev) * sin(azimuth),
                         sin(elev));
 
+    const float EYE_DISTANCE_TO_EARTH_CENTER    = EARTH_RADIUS + settings.sky.altitude;
     vec3 ray_origin = vec3(0.0, 0.0, EYE_DISTANCE_TO_EARTH_CENTER);
 
     float atmos_dist  = ray_sphere_intersection(ray_origin, ray_dir, ATMOSPHERE_RADIUS);
     float ground_dist = ray_sphere_intersection(ray_origin, ray_dir, EARTH_RADIUS);
     float t_d;
-    if (EYE_ALTITUDE < ATMOSPHERE_THICKNESS) {
+    if (settings.sky.altitude < ATMOSPHERE_THICKNESS) {
         // We are inside the atmosphere
         if (ground_dist < 0.0) {
             // No ground collision, use the distance to the outer atmosphere

resources/shaders/env/sky_projection.glsl

@@ -57,7 +57,7 @@ void main()
     // Undo the non-linear transformation from the sky-view LUT
     float elev = sqrt(abs(theta) / (PI * 0.5)) * sign(theta) * 0.5 + 0.5;
 
-    vec3 col = texture(sky, vec2(azimuth, elev)).rgb;
+    vec3 col = texture(sky, vec2(azimuth, 1.0 -elev)).rgb;
 
 // #if TONEMAPPING_TECHNIQUE == 0
 //     // Apply exposure

resources/shaders/env/sky_tt_compute.glsl

@@ -26,6 +26,9 @@ void main() {
 
 layout(location = 0) in  vec2 v_uv;
 
+layout(push_constant) uniform Settings {
+    SkySettings sky;
+} settings;
 
 layout(location = 0) out vec4 outColor;
 
@@ -56,6 +59,8 @@ void main()
 
         get_atmosphere_collision_coefficients(
             altitude,
+            settings.sky.month,
+            settings.sky.aerosolTurbidity,
             aerosol_absorption, aerosol_scattering,
             molecular_absorption, molecular_scattering,
             extinction);

resources/shaders/include/sky.glsl

@@ -1,17 +1,25 @@
 // Configurable parameters
+struct SkySettings {
+    float          sunElevationDeg; 
+    int            month; 
+    float          altitude; 
+    int            aerosol; 
+
+    vec4           groundAlbedo; 
+
+    float          aerosolTurbidity;
+    int            resolution; 
+    bool           useForIBL; 
+    int            updateType; 
+};
 
 #define ANIMATE_SUN 0
-// 0=equirectangular, 1=fisheye, 2=projection
-#define CAMERA_TYPE 2
+
 // 0=Background, 1=Desert Dust, 2=Maritime Clean, 3=Maritime Mineral,
 // 4=Polar Antarctic, 5=Polar Artic, 6=Remote Continental, 7=Rural, 8=Urban
 #define AEROSOL_TYPE 8
 
-const float SUN_ELEVATION_DEGREES = 0.0;    // 0=horizon, 90=zenith
-const float EYE_ALTITUDE          = 0.5;    // km
-const int   MONTH                 = 0;      // 0-11, January to December
 const float AEROSOL_TURBIDITY     = 1.0;
-const vec4  GROUND_ALBEDO         = vec4(0.3);
 
 // Ray marching steps. More steps mean better accuracy but worse performance
 const int TRANSMITTANCE_STEPS     = 32;
@@ -49,9 +57,8 @@ const float gg                      = g*g;
 const float EARTH_RADIUS                    = 6371.0; // km
 const float ATMOSPHERE_THICKNESS            = 100.0; // km
 const float ATMOSPHERE_RADIUS               = EARTH_RADIUS + ATMOSPHERE_THICKNESS;
-const float EYE_DISTANCE_TO_EARTH_CENTER    = EARTH_RADIUS + EYE_ALTITUDE;
-const float SUN_ZENITH_COS_ANGLE            = cos(radians(90.0 - SUN_ELEVATION_DEGREES));
-const vec3 SUN_DIR                          = vec3(-sqrt(1.0 - SUN_ZENITH_COS_ANGLE*SUN_ZENITH_COS_ANGLE), 0.0, SUN_ZENITH_COS_ANGLE);
+
+
 
 #if ENABLE_SPECTRAL == 1
 // Extraterrestial Solar Irradiance Spectra, units W * m^-2 * nm^-1
@@ -162,14 +169,10 @@ const float aerosol_background_divided_by_base_density = aerosol_background_dens
 
 //-----------------------------------------------------------------------------
 
-vec3 get_sun_direction(float time)
+vec3 get_sun_direction(float sunElevationDeg)
 {
-#if ANIMATE_SUN == 0
-    return SUN_DIR;
-#else
-    float a = sin(time*0.5 - 1.5) * 0.55 + 0.45;
-    return vec3(-sqrt(1.0 - a*a), 0.0, a);
-#endif
+    float sunZenithCosAngle = cos(radians(90.0 - sunElevationDeg));
+    return vec3(-sqrt(1.0 - sunZenithCosAngle*sunZenithCosAngle), 0.0, sunZenithCosAngle);
 }
 
 /*
@@ -216,7 +219,7 @@ float aerosol_phase_function(float cos_theta)
     return INV_4PI * (1.0 - gg) / (den * sqrt(den));
 }
 
-vec4 get_multiple_scattering(sampler2D transmittance_lut, float cos_theta, float normalized_height, float d)
+vec4 get_multiple_scattering(sampler2D transmittance_lut, vec4 groundAlbedo, float cos_theta, float normalized_height, float d)
 {
 #if ENABLE_MULTIPLE_SCATTERING == 1
     // Solid angle subtended by the planet from a point at d distance
@@ -230,7 +233,7 @@ vec4 get_multiple_scattering(sampler2D transmittance_lut, float cos_theta, float
         transmittance_from_lut(transmittance_lut, 1.0, normalized_height);
 
     // 2nd order scattering from the ground
-    vec4 L_ground = PHASE_ISOTROPIC * omega * (GROUND_ALBEDO / PI) * T_to_ground * T_ground_to_sample * cos_theta;
+    vec4 L_ground = PHASE_ISOTROPIC * omega * (groundAlbedo / PI) * T_to_ground * T_ground_to_sample * cos_theta;
 
     // Fit of Earth's multiple scattering coming from other points in the atmosphere
     vec4 L_ms = 0.02 * vec4(0.217, 0.347, 0.594, 1.0) * (1.0 / (1.0 + 5.0 * exp(-17.92 * cos_theta)));
@@ -254,12 +257,12 @@ vec4 get_molecular_scattering_coefficient(float h)
  * Return the molecular volume absorption coefficient (km^-1) for a given altitude
  * in kilometers.
  */
-vec4 get_molecular_absorption_coefficient(float h)
+vec4 get_molecular_absorption_coefficient(float h, int month)
 {
     h += 1e-4; // Avoid division by 0
     float t = log(h) - 3.22261;
     float density = 3.78547397e20 * (1.0 / h) * exp(-t * t * 5.55555555);
-    return ozone_absorption_cross_section * ozone_mean_monthly_dobson[MONTH] * density;
+    return ozone_absorption_cross_section * ozone_mean_monthly_dobson[month] * density;
 }
 
 float get_aerosol_density(float h)
@@ -277,6 +280,8 @@ float get_aerosol_density(float h)
  * atmospheric medium for a given point at an altitude h.
  */
 void get_atmosphere_collision_coefficients(in float h,
+                                           in int month,
+                                           in float turbidity,
                                            out vec4 aerosol_absorption,
                                            out vec4 aerosol_scattering,
                                            out vec4 molecular_absorption,
@@ -289,10 +294,10 @@ void get_atmosphere_collision_coefficients(in float h,
     aerosol_scattering = vec4(0.0);
 #else
     float aerosol_density = get_aerosol_density(h);
-    aerosol_absorption = aerosol_absorption_cross_section * aerosol_density * AEROSOL_TURBIDITY;
-    aerosol_scattering = aerosol_scattering_cross_section * aerosol_density * AEROSOL_TURBIDITY;
+    aerosol_absorption = aerosol_absorption_cross_section * aerosol_density * turbidity;
+    aerosol_scattering = aerosol_scattering_cross_section * aerosol_density * turbidity;
 #endif
-    molecular_absorption = get_molecular_absorption_coefficient(h);
+    molecular_absorption = get_molecular_absorption_coefficient(h, month);
     molecular_scattering = get_molecular_scattering_coefficient(h);
     extinction = aerosol_absorption + aerosol_scattering + molecular_absorption + molecular_scattering;
 }

src/core/passes/enviroment_pass.cpp

@@ -39,7 +39,10 @@ void EnviromentPass::setup_uniforms(std::vector<Graphics::Frame>& frames) {
     LayoutBinding panoramaTextureBinding(UniformDataType::UNIFORM_COMBINED_IMAGE_SAMPLER, SHADER_STAGE_FRAGMENT, 0);
     LayoutBinding enviromentTextureBinding(UniformDataType::UNIFORM_COMBINED_IMAGE_SAMPLER, SHADER_STAGE_FRAGMENT, 1);
     LayoutBinding auxBufferBinding(UniformDataType::UNIFORM_BUFFER, SHADER_STAGE_FRAGMENT, 2);
-    m_descriptorPool.set_layout(0, {panoramaTextureBinding, enviromentTextureBinding, auxBufferBinding});
+    LayoutBinding proceduralPanoramaTextureBinding(
+        UniformDataType::UNIFORM_COMBINED_IMAGE_SAMPLER, SHADER_STAGE_FRAGMENT, 3);
+    m_descriptorPool.set_layout(
+        0, {panoramaTextureBinding, enviromentTextureBinding, auxBufferBinding, proceduralPanoramaTextureBinding});
 
     m_descriptorPool.allocate_descriptor_set(0, &m_envDescriptorSet);
 
@@ -83,6 +86,7 @@ void EnviromentPass::setup_shader_passes() {
                                                       {UV_ATTRIBUTE, true},
                                                       {TANGENT_ATTRIBUTE, false},
                                                       {COLOR_ATTRIBUTE, false}};
+    converterPass->settings.pushConstants          = {PushConstant(SHADER_STAGE_FRAGMENT, sizeof(float))};
 
     converterPass->build_shader_stages();
     converterPass->build(m_descriptorPool);
@@ -130,11 +134,17 @@ void EnviromentPass::render(Graphics::Frame& currentFrame, Scene* const scene, u
     cmd.set_viewport(m_imageExtent);
     ShaderPass* shaderPass = m_shaderPasses["converter"];
     cmd.bind_shaderpass(*shaderPass);
+    int panoramaType = static_cast<int>(scene->get_skybox()->get_sky_type());
+    cmd.push_constants(*shaderPass, SHADER_STAGE_FRAGMENT, &panoramaType, sizeof(float));
     cmd.bind_descriptor_set(m_envDescriptorSet, 0, *shaderPass);
     cmd.draw_geometry(*get_VAO(BasePass::vignette));
     cmd.end_renderpass(m_renderpass, m_framebuffers[0]);
 
     /*Draw Diffuse Irradiance*/
+    if (scene->get_skybox()->get_sky_type() == EnviromentType::PROCEDURAL_ENV &&
+        !scene->get_skybox()->get_sky_settings().useForIBL)
+        goto jump;
+
     cmd.begin_renderpass(m_renderpass, m_framebuffers[1]);
     cmd.set_viewport(m_irradianceResolution);
     shaderPass = m_shaderPasses["irr"];
@@ -143,13 +153,14 @@ void EnviromentPass::render(Graphics::Frame& currentFrame, Scene* const scene, u
     cmd.draw_geometry(*get_VAO(BasePass::vignette));
     cmd.end_renderpass(m_renderpass, m_framebuffers[1]);
 
+jump:
     /* Everything is updated, set to sleep */
     scene->get_skybox()->update_enviroment(false);
     set_active(false);
 }
 
 void EnviromentPass::link_previous_images(std::vector<Graphics::Image> images) {
-    // m_descriptorPool.update_descriptor(&images[0], LAYOUT_SHADER_READ_ONLY_OPTIMAL, &m_envDescriptorSet, 0);
+    m_descriptorPool.update_descriptor(&images[0], LAYOUT_SHADER_READ_ONLY_OPTIMAL, &m_envDescriptorSet, 3);
 }
 void EnviromentPass::update_uniforms(uint32_t frameIndex, Scene* const scene) {
     if (!scene->get_skybox())

src/core/passes/sky_pass.cpp

@@ -61,6 +61,7 @@ void SkyPass::setup_shader_passes() {
                                                {TANGENT_ATTRIBUTE, false},
                                                {COLOR_ATTRIBUTE, false}};
 
+
     ttPass->build_shader_stages();
     ttPass->build(m_descriptorPool);
 
@@ -71,6 +72,7 @@ void SkyPass::setup_shader_passes() {
     skyPass->settings.pushConstants          = {PushConstant(SHADER_STAGE_FRAGMENT, sizeof(Core::SkySettings))};
     skyPass->settings.descriptorSetLayoutIDs = ttPass->settings.descriptorSetLayoutIDs;
     skyPass->graphicSettings.attributes      = ttPass->graphicSettings.attributes;
+    
 
     skyPass->build_shader_stages();
     skyPass->build(m_descriptorPool);
@@ -134,4 +136,30 @@ void SkyPass::render(Graphics::Frame& currentFrame, Scene* const scene, uint32_t
 
 } // namespace Core
 
+// struct Matrix4x4 {
+//     float m[4][4];
+// };
+
+// struct EulerAngles {
+//     float pitch; // Rotation around X-axis
+//     float yaw;   // Rotation around Y-axis
+//     float roll;  // Rotation around Z-axis
+// };
+
+// // Function to extract Euler angles from the view matrix
+// EulerAngles extractEulerAnglesFromViewMatrix(const Matrix4x4& viewMatrix) {
+//     // Extract the rotation matrix (upper-left 3x3)
+//     float r00 = viewMatrix.m[0][0], r01 = viewMatrix.m[0][1], r02 = viewMatrix.m[0][2];
+//     float r10 = viewMatrix.m[1][0], r11 = viewMatrix.m[1][1], r12 = viewMatrix.m[1][2];
+//     float r20 = viewMatrix.m[2][0], r21 = viewMatrix.m[2][1], r22 = viewMatrix.m[2][2];
+
+//     // Calculate yaw, pitch, and roll
+//     float yaw = std::atan2(r10, r00); // Yaw (rotation around Y-axis)
+//     float pitch = std::atan2(-r20, std::sqrt(r00 * r00 + r10 * r10)); // Pitch (rotation around X-axis)
+//     float roll = std::atan2(r21, r22); // Roll (rotation around Z-axis)
+
+//     // Return Euler angles
+//     return { pitch, yaw, roll };
+// }
+
 VULKAN_ENGINE_NAMESPACE_END