physical_sky.h File Reference

#include "vkpt.h"
#include "shader/sky.h"

Go to the source code of this file.

Classes
struct	PhysicalSkyDesc

Typedefs
typedef struct PhysicalSkyDesc	PhysicalSkyDesc_t

Functions
void	vkpt_evaluate_sun_light (sun_light_t *light, const vec3_t sky_matrix[3], float time)
VkResult	vkpt_physical_sky_initialize ()
VkResult	vkpt_physical_sky_destroy ()
VkResult	vkpt_physical_sky_beginRegistration ()
VkResult	vkpt_physical_sky_endRegistration ()
VkResult	vkpt_physical_sky_create_pipelines ()
VkResult	vkpt_physical_sky_destroy_pipelines ()
VkResult	vkpt_physical_sky_record_cmd_buffer (VkCommandBuffer cmd_buf)
VkResult	vkpt_physical_sky_update_ubo (QVKUniformBuffer_t *ubo, const sun_light_t *light, qboolean render_world)
void	vkpt_physical_sky_latch_local_time ()
qboolean	vkpt_physical_sky_needs_update ()
void	vkpt_next_sun_preset ()
void	InitialiseSkyCVars ()
void	UpdatePhysicalSkyCVars ()
const PhysicalSkyDesc_t *	GetSkyPreset (uint16_t index)
void	CalculateDirectionToSun (float DayOfYear, float TimeOfDay, float LatitudeDegrees, vec3_t result)

Typedef Documentation

PhysicalSkyDesc_t

typedef struct PhysicalSkyDesc PhysicalSkyDesc_t

Function Documentation

CalculateDirectionToSun()

void CalculateDirectionToSun	(	float	DayOfYear,
		float	TimeOfDay,
		float	LatitudeDegrees,
		vec3_t	result
	)

Definition at line 1041 of file physical_sky.c.

{
    const float AxialTilt = 23.439f;
    const float DaysInYear = 365.25f;
    const float SpringEquinoxDay = 79.0f; // Mar 20
 
    float altitudeAtNoon = 90 - LatitudeDegrees + AxialTilt * sinf((DayOfYear - SpringEquinoxDay) / DaysInYear * 2.0f * M_PI);
    altitudeAtNoon = altitudeAtNoon * M_PI / 180.f;
 
    float altitudeOfEarthAxis = 180 - LatitudeDegrees;
    altitudeOfEarthAxis = altitudeOfEarthAxis * M_PI / 180.f;
 
    // X -> North
    // Y -> Zenith
    // Z -> East
 
    vec3_t noonVector = { cosf(altitudeAtNoon), sinf(altitudeAtNoon), 0.0f };
    vec3_t earthAxis = { cosf(altitudeOfEarthAxis), sinf(altitudeOfEarthAxis), 0.0f };
 
    float angleFromNoon = (TimeOfDay - 12.0f) / 24.0f * 2.f * M_PI;
 
    vec4_t dayRotation;
    rotationQuat(earthAxis, -angleFromNoon, dayRotation);
  
    vec4_t dayRotationInv = { dayRotation[0], dayRotation[1], dayRotation[2], dayRotation[3] };
    inverseQuat(dayRotationInv);
 
 
    // = normalize(dayRotationInv * makequat(0.f, noonVector) * dayRotation);
    vec4_t sunDirection = { 0.0f, 0.0f, 0.0f, 0.0f };
    vec4_t noonQuat = { 0.0f, noonVector[0], noonVector[1], noonVector[2] };
    quatMult(dayRotationInv, noonQuat, sunDirection);
    quatMult(sunDirection, dayRotation, sunDirection);
    normalizeQuat(sunDirection);
 
    result[0] = sunDirection[1];
    result[1] = sunDirection[3];
    result[2] = sunDirection[2];
}

Referenced by vkpt_evaluate_sun_light().

GetSkyPreset()

const PhysicalSkyDesc_t* GetSkyPreset

(

uint16_t

index

)

Definition at line 986 of file physical_sky.c.

{
    if (index >= 0 && index < q_countof(skyPresets))
        return &skyPresets[index];
 
    return &skyPresets[0];
}

Referenced by UpdatePhysicalSkyCVars(), vkpt_evaluate_sun_light(), and vkpt_physical_sky_update_ubo().

InitialiseSkyCVars()

void InitialiseSkyCVars

(

)

Definition at line 881 of file physical_sky.c.

{
    static char _rgb[3] = {'r', 'g', 'b'};
 
    // sun
    for (int i = 0; i < 3; ++i)
    {
        char buff[32]; 
        snprintf(buff, 32, "sun_color_%c", _rgb[i]);
        sun_color[i] = Cvar_Get(buff, "1.0", 0);
        sun_color[i]->changed = physical_sky_cvar_changed;
    }
 
    sun_elevation = Cvar_Get("sun_elevation", "45", 0);
    sun_elevation->changed = physical_sky_cvar_changed;
 
    sun_azimuth = Cvar_Get("sun_azimuth", "345", 0); 
    sun_azimuth->changed = physical_sky_cvar_changed;
 
    sun_angle = Cvar_Get("sun_angle", "1.0", 0); 
    sun_angle->changed = physical_sky_cvar_changed;
    
    sun_brightness = Cvar_Get("sun_brightness", "10", 0); 
    sun_brightness->changed = physical_sky_cvar_changed;
 
    sky_scattering = Cvar_Get("sky_scattering", "5.0", 0);
    sky_scattering->changed = physical_sky_cvar_changed;
 
    sky_transmittance = Cvar_Get("sky_transmittance", "10.0", 0);
    sky_transmittance->changed = physical_sky_cvar_changed;
 
    sky_phase_g = Cvar_Get("sky_phase_g", "0.9", 0);
    sky_phase_g->changed = physical_sky_cvar_changed;
 
    sky_amb_phase_g = Cvar_Get("sky_amb_phase_g", "0.3", 0);
    sky_amb_phase_g->changed = physical_sky_cvar_changed;
 
    sun_bounce = Cvar_Get("sun_bounce", "1.0", 0); 
    sun_bounce->changed = physical_sky_cvar_changed;
 
    sun_animate = Cvar_Get("sun_animate", "0", 0); 
    sun_animate->changed = physical_sky_cvar_changed;
 
    sun_preset = Cvar_Get("sun_preset", va("%d", SUN_PRESET_MORNING), CVAR_ARCHIVE);
    sun_preset->changed = physical_sky_cvar_changed;
 
    sun_latitude = Cvar_Get("sun_latitude", "32.9", CVAR_ARCHIVE); // latitude of former HQ of id Software in Richardson, TX
    sun_latitude->changed = physical_sky_cvar_changed;
 
    sun_gamepad = Cvar_Get("sun_gamepad", "0", 0);
 
    // sky
 
    physical_sky = Cvar_Get("physical_sky", "2", 0);
    physical_sky->changed = physical_sky_cvar_changed;
 
    physical_sky_draw_clouds = Cvar_Get("physical_sky_draw_clouds", "1", 0);
    physical_sky_draw_clouds->changed = physical_sky_cvar_changed;
 
    physical_sky_space = Cvar_Get("physical_sky_space", "0", 0);
    physical_sky_space->changed = physical_sky_cvar_changed;
 
    physical_sky_brightness = Cvar_Get("physical_sky_brightness", "0", 0);
    physical_sky_brightness->changed = physical_sky_cvar_changed;
}

Referenced by R_Init_RTX().

UpdatePhysicalSkyCVars()

void UpdatePhysicalSkyCVars

(

)

Definition at line 947 of file physical_sky.c.

{
    PhysicalSkyDesc_t const * sky = GetSkyPreset(physical_sky->integer);
 
    // sun
    for (int i = 0; i < 3; ++i)
        Cvar_SetValue(sun_color[i], sky->sunColor[i], FROM_CODE);
    
    Cvar_SetValue(sun_angle, sky->sunAngularDiameter, FROM_CODE);
    
    skyNeedsUpdate = VK_TRUE;
}

Referenced by R_BeginRegistration_RTX(), and vkpt_evaluate_sun_light().

vkpt_evaluate_sun_light()

void vkpt_evaluate_sun_light	(	sun_light_t *	light,
		const vec3_t	sky_matrix[3],
		float	time
	)

Definition at line 620 of file physical_sky.c.

{
    static uint16_t skyIndex = -1;
    if (physical_sky->integer != skyIndex)
    {   // update cvars with presets if the user changed the sky
        UpdatePhysicalSkyCVars();
        skyIndex = physical_sky->integer;
    }
 
    PhysicalSkyDesc_t const * skyDesc = GetSkyPreset(skyIndex);
 
    if ((skyDesc->flags & PHYSICAL_SKY_FLAG_USE_SKYBOX) != 0)
    {
        // physical sky is disabled - no direct sun light in this mode
        memset(light, 0, sizeof(*light));
        return;
    }
 
    if (skyIndex != current_preset)
    {
        vkQueueWaitIdle(qvk.queue_graphics);
        SkyLoadScatterParameters(skyDesc->preset);
        current_preset = skyIndex;
    }
 
    process_gamepad_input();
 
    float azimuth, elevation;
 
    static float start_time = 0.0f, sun_animate_changed = 0.0f;
    if (sun_animate->value != sun_animate_changed)
    {
        start_time = time;
        sun_animate_changed = sun_animate->value;
    }
 
    const int preset = active_sun_preset();
 
    if ((preset == SUN_PRESET_CURRENT_TIME) || (preset == SUN_PRESET_FAST_TIME))
    {
        qboolean fast_time = (preset == SUN_PRESET_FAST_TIME);
 
        struct tm* local_time;
 
        if (fast_time)
            local_time = gmtime(&latched_local_time);
        else
            local_time = localtime(&latched_local_time);
 
        float time_of_day = local_time->tm_hour + local_time->tm_min / 60.f;
        if (fast_time)
            time_of_day *= 12.f;
        else if (local_time->tm_isdst)
            time_of_day -= 1.f;
 
        CalculateDirectionToSun(local_time->tm_yday, time_of_day, sun_latitude->value, light->direction_envmap);
    }
    else
    {
        switch (preset)
        {
        case SUN_PRESET_NIGHT:
            elevation = -90.f;
            azimuth = 0.f;
            break;
 
        case SUN_PRESET_DAWN:
            elevation = -3.f;
            azimuth = 0.f;
            break;
 
        case SUN_PRESET_MORNING:
            elevation = 25.f;
            azimuth = -15.f;
            break;
 
        case SUN_PRESET_NOON:
            elevation = 80.f;
            azimuth = -75.f;
            break;
 
        case SUN_PRESET_EVENING:
            elevation = 15.f;
            azimuth = 190.f;
            break;
 
        case SUN_PRESET_DUSK:
            elevation = -6.f;
            azimuth = 205.f;
            break;
 
        default:
            if (sun_animate->value > 0.0f)
            {
                float elapsed = (time - start_time) * 1000.f * sun_animate->value;
 
                azimuth = fmod(sun_azimuth->value + elapsed / (24.f * 60.f * 60.f), 360.0f);
 
                float e = fmod(sun_elevation->value + elapsed / (60.f * 60.f), 360.0f);
                if (e > 270.f)
                    elevation = -(360.f - e);
                else if (e > 180.0f)
                {
                    elevation = -(e - 180.0f);
                    azimuth = fmod(azimuth + 180.f, 360.f);
                }
                else if (e > 90.0f)
                {
                    elevation = 180.0f - e;
                    azimuth = fmod(azimuth + 180.f, 360.f);
                }
                else
                    elevation = e;
                elevation = max(-90, min(90, elevation));
 
                skyNeedsUpdate = VK_TRUE;
            }
            else
            {
                azimuth = sun_azimuth->value;
                elevation = sun_elevation->value;
            }
            break;
        }
 
        float elevation_rad = elevation * M_PI / 180.0f; //max(-20.f, min(90.f, elevation)) * M_PI / 180.f;
        float azimuth_rad = azimuth * M_PI / 180.f;
        light->direction_envmap[0] = cosf(azimuth_rad) * cosf(elevation_rad);
        light->direction_envmap[1] = sinf(azimuth_rad) * cosf(elevation_rad);
        light->direction_envmap[2] = sinf(elevation_rad);
    }
 
    light->angular_size_rad = max(1.f, min(10.f, sun_angle->value)) * M_PI / 180.f;
 
    light->use_physical_sky = qtrue;
 
    // color before occlusion
    vec3_t sunColor = { sun_color[0]->value, sun_color[1]->value, sun_color[2]->value };
    VectorScale(sunColor, sun_brightness->value, light->color);
 
    // potentially visible - can be overridden if readback data says it's occluded
    if (physical_sky_space->integer)
        light->visible = qtrue;
    else
        light->visible = (light->direction_envmap[2] >= -sinf(light->angular_size_rad * 0.5f));
 
    vec3_t sun_direction_world = { 0.f };
    sun_direction_world[0] = light->direction_envmap[0] * sky_matrix[0][0] + light->direction_envmap[1] * sky_matrix[0][1] + light->direction_envmap[2] * sky_matrix[0][2];
    sun_direction_world[1] = light->direction_envmap[0] * sky_matrix[1][0] + light->direction_envmap[1] * sky_matrix[1][1] + light->direction_envmap[2] * sky_matrix[1][2];
    sun_direction_world[2] = light->direction_envmap[0] * sky_matrix[2][0] + light->direction_envmap[1] * sky_matrix[2][1] + light->direction_envmap[2] * sky_matrix[2][2];
    VectorCopy(sun_direction_world, light->direction);
}

Referenced by R_RenderFrame_RTX().

vkpt_next_sun_preset()

void vkpt_next_sun_preset

(

)

Definition at line 603 of file physical_sky.c.

{
    int preset;
 
    if (sun_preset->integer < SUN_PRESET_NIGHT || sun_preset->integer > SUN_PRESET_DUSK)
        preset = SUN_PRESET_MORNING;
    else
    {
        preset = sun_preset->integer + 1;
        if (preset > SUN_PRESET_DUSK)
            preset = SUN_PRESET_NIGHT;
    }
 
    Cvar_SetByVar(sun_preset, va("%d", preset), FROM_CONSOLE);
}

Referenced by R_Init_RTX().

vkpt_physical_sky_beginRegistration()

VkResult vkpt_physical_sky_beginRegistration

(

)

Definition at line 338 of file physical_sky.c.

{
    physical_sky_planet_albedo_map = 0;
    physical_sky_planet_normal_map = 0;
    return VK_SUCCESS;
}

Referenced by R_BeginRegistration_RTX().

vkpt_physical_sky_create_pipelines()

VkResult vkpt_physical_sky_create_pipelines

(

)

Definition at line 364 of file physical_sky.c.

{
    {
        VkComputePipelineCreateInfo pipeline_info = {
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .stage = SHADER_STAGE(QVK_MOD_PHYSICAL_SKY_COMP, VK_SHADER_STAGE_COMPUTE_BIT),
            .layout = pipeline_layout_physical_sky
        };
 
        _VK(vkCreateComputePipelines(qvk.device, 0, 1, &pipeline_info, 0, &pipeline_physical_sky));
    }
 
    {
        VkComputePipelineCreateInfo pipeline_info = {
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .stage = SHADER_STAGE(QVK_MOD_PHYSICAL_SKY_SPACE_COMP, VK_SHADER_STAGE_COMPUTE_BIT),
            .layout = pipeline_layout_physical_sky
        };
 
        _VK(vkCreateComputePipelines(qvk.device, 0, 1, &pipeline_info, 0, &pipeline_physical_sky_space));
    }
 
    {
        VkComputePipelineCreateInfo pipeline_info = {
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .stage = SHADER_STAGE(QVK_MOD_SKY_BUFFER_RESOLVE_COMP, VK_SHADER_STAGE_COMPUTE_BIT),
            .layout = pipeline_layout_resolve
        };
 
        _VK(vkCreateComputePipelines(qvk.device, 0, 1, &pipeline_info, 0, &pipeline_resolve));
    }
 
    skyNeedsUpdate = VK_TRUE;
    
    return VK_SUCCESS;
}

vkpt_physical_sky_destroy()

VkResult vkpt_physical_sky_destroy

(

)

Definition at line 315 of file physical_sky.c.

{
    current_preset = 0;
 
    ReleaseShadowmapResources();
    SkyReleaseDataGPU();
    
    vkDestroyPipelineLayout(qvk.device, pipeline_layout_physical_sky, NULL);
    pipeline_layout_physical_sky = VK_NULL_HANDLE;
    vkDestroyPipelineLayout(qvk.device, pipeline_layout_resolve, NULL);
    pipeline_layout_resolve = VK_NULL_HANDLE;
    destroyEnvTexture();
 
    if (game_controller)
    {
        SDL_GameControllerClose(game_controller);
        game_controller = 0;
    }
 
    return VK_SUCCESS;
}

vkpt_physical_sky_destroy_pipelines()

VkResult vkpt_physical_sky_destroy_pipelines

(

)

Definition at line 402 of file physical_sky.c.

{
    vkDestroyPipeline(qvk.device, pipeline_physical_sky, NULL);
    pipeline_physical_sky = VK_NULL_HANDLE;
 
    vkDestroyPipeline(qvk.device, pipeline_physical_sky_space, NULL);
    pipeline_physical_sky_space = VK_NULL_HANDLE;
 
    vkDestroyPipeline(qvk.device, pipeline_resolve, NULL);
    pipeline_resolve = VK_NULL_HANDLE;
 
    return VK_SUCCESS;
}

vkpt_physical_sky_endRegistration()

VkResult vkpt_physical_sky_endRegistration

(

)

Definition at line 346 of file physical_sky.c.

{
    if (physical_sky_space->integer > 0)
    {
        image_t const * albedo_map = IMG_Find("env/planet_albedo.tga", IT_SKIN, IF_SRGB);
        if (albedo_map != R_NOTEXTURE) {
            physical_sky_planet_albedo_map = albedo_map - r_images;
        }
 
        image_t const * normal_map = IMG_Find("env/planet_normal.tga", IT_SKIN, IF_SRGB);
        if (normal_map != R_NOTEXTURE) {
            physical_sky_planet_normal_map = normal_map - r_images;
        }
    }
    return VK_SUCCESS;
}

Referenced by R_EndRegistration_RTX().

vkpt_physical_sky_initialize()

VkResult vkpt_physical_sky_initialize

(

)

Definition at line 249 of file physical_sky.c.

{
    current_preset = 0;
 
    SkyInitializeDataGPU();
 
    InitializeShadowmapResources();
 
    {
        VkDescriptorSetLayout desc_set_layouts[] = {
            qvk.desc_set_layout_ubo,
            qvk.desc_set_layout_textures,
            qvk.desc_set_layout_vertex_buffer,
            *SkyGetDescriptorLayout()
        };
 
        VkPushConstantRange push_constant_range = {
            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
            .offset = 0,
            .size = sizeof(float) * 16,
        };
 
        CREATE_PIPELINE_LAYOUT(qvk.device, &pipeline_layout_physical_sky,
            .setLayoutCount = LENGTH(desc_set_layouts),
            .pSetLayouts = desc_set_layouts,
            .pushConstantRangeCount = 1,
            .pPushConstantRanges = &push_constant_range,
        );
 
        ATTACH_LABEL_VARIABLE(pipeline_layout_physical_sky, PIPELINE_LAYOUT);
    }
 
    {
        VkDescriptorSetLayout desc_set_layouts[] = {
            qvk.desc_set_layout_ubo,
            qvk.desc_set_layout_vertex_buffer
        };
 
        CREATE_PIPELINE_LAYOUT(qvk.device, &pipeline_layout_resolve,
            .setLayoutCount = LENGTH(desc_set_layouts),
            .pSetLayouts = desc_set_layouts,
            );
        ATTACH_LABEL_VARIABLE(pipeline_layout_resolve, PIPELINE_LAYOUT);
    }
 
    if (!sdl_initialized)
    {
        SDL_InitSubSystem(SDL_INIT_JOYSTICK);
        sdl_initialized = qtrue;
    }
 
    for (int i = 0; i < SDL_NumJoysticks(); i++)
    {
        if (SDL_IsGameController(i))
        {
            game_controller = SDL_GameControllerOpen(i);
            break;
        }
    }
 
 
 
    return initializeEnvTexture(width, height);
}

vkpt_physical_sky_latch_local_time()

void vkpt_physical_sky_latch_local_time

(

)

Definition at line 75 of file physical_sky.c.

{
    time(&latched_local_time);
}

Referenced by R_BeginRegistration_RTX().

vkpt_physical_sky_needs_update()

qboolean vkpt_physical_sky_needs_update

(

)

Definition at line 459 of file physical_sky.c.

{
    return skyNeedsUpdate;
}

Referenced by R_RenderFrame_RTX().

vkpt_physical_sky_record_cmd_buffer()

VkResult vkpt_physical_sky_record_cmd_buffer

(

VkCommandBuffer

cmd_buf

)

Definition at line 467 of file physical_sky.c.

{
    if (!skyNeedsUpdate)
        return VK_SUCCESS;
 
    RecordCommandBufferShadowmap(cmd_buf);
 
    reset_sun_color_buffer(cmd_buf);
 
    {
        VkDescriptorSet desc_sets[] = {
            qvk.desc_set_ubo,
            qvk_get_current_desc_set_textures(),
            qvk.desc_set_vertex_buffer,
            SkyGetDescriptorSet(qvk.current_frame_index)
        };
 
        if (physical_sky_space->integer > 0) {
            vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_physical_sky_space);
        } else {
            vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_physical_sky);
        }
 
        vkCmdPushConstants(cmd_buf, pipeline_layout_physical_sky, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(float) * 16, terrain_shadowmap_viewproj);
 
        vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE,
            pipeline_layout_physical_sky, 0, LENGTH(desc_sets), desc_sets, 0, 0);
        const int group_size = 16;
        vkCmdDispatch(cmd_buf, width / group_size, height / group_size, 6);
    }
 
    BARRIER_COMPUTE(cmd_buf, img_envmap);
 
    BUFFER_BARRIER(cmd_buf,
        .buffer = qvk.buf_sun_color.buffer,
        .offset = 0,
        .size = VK_WHOLE_SIZE,
        .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT
    );
 
    {
        VkDescriptorSet desc_sets[] = {
            qvk.desc_set_ubo,
            qvk.desc_set_vertex_buffer,
        };
 
        vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_resolve);
        vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE,
            pipeline_layout_resolve, 0, LENGTH(desc_sets), desc_sets, 0, 0);
        
        vkCmdDispatch(cmd_buf, 1, 1, 1);
    }
 
    BUFFER_BARRIER(cmd_buf,
        .buffer = qvk.buf_sun_color.buffer,
        .offset = 0,
        .size = VK_WHOLE_SIZE,
        .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT
    );
 
    skyNeedsUpdate = VK_FALSE;
    
    return VK_SUCCESS;
}

Referenced by R_RenderFrame_RTX().

vkpt_physical_sky_update_ubo()

VkResult vkpt_physical_sky_update_ubo	(	QVKUniformBuffer_t *	ubo,
		const sun_light_t *	light,
		qboolean	render_world
	)

Definition at line 774 of file physical_sky.c.

{
    PhysicalSkyDesc_t const * skyDesc = GetSkyPreset(physical_sky->integer);
 
    if(physical_sky_space->integer)
        ubo->pt_env_scale = 0.3f;
    else
    {
        const float min_brightness = -10.f;
        const float max_brightness = 2.f;
 
        float brightness = max(min_brightness, min(max_brightness, physical_sky_brightness->value));
        ubo->pt_env_scale = exp2f(brightness - 2.f);
    }
 
    // sun
 
    ubo->sun_bounce_scale = sun_bounce->value;
    ubo->sun_tan_half_angle = tanf(light->angular_size_rad * 0.5f);
    ubo->sun_cos_half_angle = cosf(light->angular_size_rad * 0.5f);
    ubo->sun_solid_angle = 2 * M_PI * (float)(1.0 - cos(light->angular_size_rad * 0.5)); // use double for precision
    //ubo->sun_solid_angle = max(ubo->sun_solid_angle, 1e-3f);
 
    VectorCopy(light->color, ubo->sun_color);
    VectorCopy(light->direction_envmap, ubo->sun_direction_envmap);
    VectorCopy(light->direction, ubo->sun_direction);
 
    if (light->direction[2] >= 0.99f)
    {
        VectorSet(ubo->sun_tangent, 1.f, 0.f, 0.f);
        VectorSet(ubo->sun_bitangent, 0.f, 1.f, 0.f);
    }
    else
    {
        vec3_t up;
        VectorSet(up, 0.f, 0.f, 1.f);
        CrossProduct(light->direction, up, ubo->sun_tangent);
        VectorNormalize(ubo->sun_tangent);
        CrossProduct(light->direction, ubo->sun_tangent, ubo->sun_bitangent);
        VectorNormalize(ubo->sun_bitangent);
    }
    // clouds
 
    ubo->sky_transmittance = sky_transmittance->value;
    ubo->sky_phase_g = sky_phase_g->value;
    ubo->sky_amb_phase_g = sky_amb_phase_g->value;
    ubo->sky_scattering = sky_scattering->value;
 
    // atmosphere
 
    if (!render_world)
        ubo->environment_type = ENVIRONMENT_NONE;
    else if (light->use_physical_sky)
        ubo->environment_type = ENVIRONMENT_DYNAMIC;
    else
        ubo->environment_type = ENVIRONMENT_STATIC;
 
    if (light->use_physical_sky)
    {
        uint32_t flags = skyDesc->flags;
        // adjust flags from cvars here
 
        if (physical_sky_draw_clouds->value > 0.0f)
            flags = flags | PHYSICAL_SKY_FLAG_DRAW_CLOUDS;
        else
            flags = flags & (~PHYSICAL_SKY_FLAG_DRAW_CLOUDS);
 
        ubo->physical_sky_flags = flags;
 
        // compute approximation of reflected radiance from ground
        vec3_t ground_radiance;
        VectorCopy(skyDesc->groundAlbedo, ground_radiance);
        VectorScale(ground_radiance, max(0.f, light->direction_envmap[2]), ground_radiance); // N.L
        VectorVectorScale(ground_radiance, light->color, ground_radiance);
 
        VectorCopy(ground_radiance, ubo->physical_sky_ground_radiance);
    }
    else
        skyNeedsUpdate = VK_FALSE;
 
    // planet
 
    ubo->planet_albedo_map = physical_sky_planet_albedo_map;
    ubo->planet_normal_map = physical_sky_planet_normal_map;
 
    ubo->sun_visible = light->visible;
 
    if (render_world && !(skyDesc->flags & PHYSICAL_SKY_FLAG_USE_SKYBOX))
    {
        vec3_t forward;
        VectorScale(light->direction_envmap, -1.0f, forward);
        UpdateTerrainShadowMapView(forward);
    }
 
    return VK_SUCCESS;
}

Referenced by R_RenderFrame_RTX().