mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-12 19:06:09 -10:00
Fabian WoltermannandClaude Opus 5.5
7f3e5fae60
* Add RTAO and unify raytraced/shadow-mapped shadow softness on sun angular size Raytraced shadow penumbras needed a hand-authored $SunAngularSize: in stars.tbl, which no shipped content sets -- so in practice nothing ever got a penumbra, and the shadow-mapped path's $Shadow Smoothness Factor: had no relation to it at all. Derive a size from the sun bitmap instead and drive both methods from the same number. g3_render_rect_screen_aligned_2d() sizes the sun quad so its rad is the tangent of the half-angle it subtends, making tan(angular radius) equal to 0.05 * the mission's +Scale: * the emitting disc's fraction of the bitmap. That fraction is the area of the pixels at or above 90% of the brightest one, converted to an equivalent radius. Across 90 sun bitmaps from retail, the MediaVPs, Blue Planet and BtA it lands at a median of 0.261 (retail's chunkier art at 0.487), and the threshold acts as a constant factor rather than a per-bitmap judgement call -- Spearman rho 0.96 between a 90% and a 50% cutoff. Taken literally that yields suns 3.9-8.5x Sol's apparent diameter once +Scale: is folded in (median 1.55, up to 5.0 in retail's own missions), so the measurement is scaled by 0.25 and clamped to 1.5 degrees, putting typical content near Sol. Derivation is the default: $SunAngularSize: 0 asks for hard shadows, an explicit value still wins, and missions can also set +AngularSize: on an individual sun to override both, with FRED and QtFRED UI (validation and fallback included) to author it. Bitmaps that can't be read -- and the deliberately blank sun bitmaps mods ship to get a light source with no visible disc -- fall back to hard shadows rather than to the widest possible penumbra. That angular size now sizes the raytraced penumbra cone directly (traceShadowRayCone() in shadows.sdr), with sample count following the same Shadow_quality tier that picks the shadow map's resolution (1 ray at Low, up to 16 at Ultra) rather than being a separate setting. The shadow-mapped path's tabled smoothness values were tuned by eye against Sol-sized retail/MediaVPs art, so shadow_smoothness_scale() in shadows.cpp scales them by the active sun's size relative to Sol, clamped to what the shadow map can represent (shadow_clamp_smoothness()). The two methods still disagree about occluder distance -- the raytracer uses the real one, the shadow map's tabled values stand in for a blocker distance pinned to the cascade's own extent -- so RT_SHADOW_SUN_SIZE_CALIBRATION in shadows.sdr is a constant factor that makes a given $SunAngularSize: read as roughly the same softness either way; it's the number to revisit if the shadow map ever grows a real blocker search. Also adds RTAO (raytraced ambient occlusion) sharing the same TLAS as the shadow rays, with lighting-profile-driven radius/strength, and lab controls for RT shadow quality (Low/High), the local light cap, RT shadow samples, RTAO, and an angular-size override for comparing both shadow methods against the same sun. All are safe to change live: they only gate which lights are picked as shadow casters or scale existing uniforms while filling the per-frame light data. Co-Authored-By: Claude Opus 5 <[email protected]> * Add shadow contact hardening via PCSS blocker search The shadow-mapped path's penumbra width was a fixed per-cascade value (shadow_smoothness_scale()'s ceiling), so every occluder blurred its shadow by the same amount regardless of how close it actually was to the receiver -- unlike the raytraced path, which gets that for free from traceShadowRayCone()'s real occluder distance. Close that gap with PCSS: search nearby texels for occluders, then scale the filter radius by how far away they were. The blocker search (pcssBlockerSearch() in shadows.sdr) needs raw, uncompared depth reads, which the existing PCF sampler can't do -- it's bound with a compare mode for the hardware shadow-compare instructions the filtered sampling itself relies on. So shadow maps now get a second sampler, shadow_map_raw, bound to the same texture with compare mode off; on OpenGL that needs a second sampler object and GL 3.3 (shadow_contact_hardening_supported()), Vulkan can always bind it. Where the raw sampler isn't available, or the new Graphics.ShadowContactHardening option is off, shadows_start_render() sets Shadow_penumbra_scale[cascade] to -1 as a sentinel and pcssPenumbraRadius() (shadows.sdr) falls straight back to the fixed radius, bit-identical to the pre-contact-hardening behavior and skipping the extra texture reads. When it is on, shadows_start_render() computes each cascade's penumbra scale from its own frustum extents and the sun's tanθ; the shader turns that plus the blocker search's average depth into a per-pixel radius, clamped to [1 texel, the old fixed ceiling]. A blocker search that finds nothing doesn't fall back to "no shadow" -- a sparse 8-tap search can miss a thin occluder, so it instead runs the full filter at the hardest (1-texel) radius, trading a touch of extra blur for not popping a real shadow to nothing. Drops RT_SHADOW_SUN_SIZE_CALIBRATION accordingly: that constant existed only to fake a blocker-distance-driven penumbra on the shadow-mapped path by pre-scaling the raytraced cone to match it, and the shadow-mapped path now has a real blocker search of its own, so the raytraced cone goes back to its physically correct size. * Apply review feedback on softer shadows - Bind the GL raw-depth sampler on unit 11 in the deferred pass and unbind it after the pass. - Enable RTAO only when shadows are on, and remove the RTAO option when ray tracing is not supported. - Use every second Poisson tap in the PCSS blocker search. - Use TLAS-relative ray origins for RTAO. - Gate +AngularSize: at version 27.0. - Measure an .eff sun from its first frame, and skip the measurement when shadows are off. - Guard the GL 3.3 sampler check for GLES builds. - Restore the lab session overrides when the lab closes. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * apply review suggestions * Fix review findings and build the ray-tracing structure once per frame Build the ray-tracing TLAS one time in each frame, in vulkan_scene_texture_begin(), where no render pass is open. Remove the TLAS build from the shadow pass and the second build in vulkan_deferred_lighting_finish(). Remove gr_build_shadow_tlas. Move the RTAO inputs and the deferred ray inputs (ray origin, cull mask, bias) into globalDeferredData. Write them in each frame with shadows_fill_deferred_global_data(). RTAO now works with shadows off and in frames with no sun. Other fixes from the review: - Add the sampler2DArray precision to the OpenGL ES shader blocks. - Declare shadowCascadeParams one time, in shadow_cascade_params.sdr. - Use one ray function for traceShadowRay() and traceShadowRayCone(). - Restore the shadow method and the raytraced light limits when the lab closes. - Limit the sun angular size to 90 degrees in stars.tbl and in missions. - Make the OpenGL sampler part of the texture unit binding, and name the raw shadow map unit SHADOW_MAP_RAW_TEXTURE_UNIT. - Measure the sun disc when the sun bitmap loads, not in the draw path. - Use starfield_copy_entry_to_instance() in stars_set_data(). - Share the sun quad radius as SUN_QUAD_RADIUS. - Correct the sun size tooltips and comments: the size affects both shadow methods. Co-Authored-By: Claude Opus 5.5 <[email protected]> --------- Co-authored-by: Claude Opus 5 <[email protected]>
80 lines
2.3 KiB
C++
80 lines
2.3 KiB
C++
#include "lab/labv2.h"
|
|
#include "lab/labv2_internal.h"
|
|
#include "lab/manager/lab_manager.h"
|
|
#include "gamesequence/gamesequence.h"
|
|
#include "graphics/rtao.h"
|
|
#include "graphics/shadows.h"
|
|
#include "starfield/starfield.h"
|
|
|
|
static std::unique_ptr<LabManager> LMGR;
|
|
|
|
const std::unique_ptr<LabManager> &getLabManager() {
|
|
if (LMGR == nullptr) {
|
|
LMGR.reset(new LabManager());
|
|
}
|
|
|
|
return LMGR;
|
|
}
|
|
|
|
namespace {
|
|
// The lab changes these settings directly, so we save them when the lab opens and restore them when it closes.
|
|
// Each LabRenderer setter that writes a game global must have a field here.
|
|
struct LabSavedSettings {
|
|
ShadowRenderMethod shadow_render_method;
|
|
RTShadowQuality rt_shadow_quality;
|
|
int max_rt_shadow_lights;
|
|
int max_rt_shadow_local_lights;
|
|
float rt_shadow_bias_min;
|
|
float rt_shadow_bias_max;
|
|
int rt_shadow_samples_override;
|
|
float sun_angular_size_override;
|
|
int rtao_samples;
|
|
bool shadow_contact_hardening_enabled;
|
|
};
|
|
|
|
bool Lab_settings_saved = false;
|
|
LabSavedSettings Lab_saved_settings;
|
|
}
|
|
|
|
void lab_init() {
|
|
gr_set_clear_color(0, 0, 0);
|
|
|
|
Lab_saved_settings = {Shadow_render_method,
|
|
Rt_shadow_quality,
|
|
Max_rt_shadow_lights,
|
|
Max_rt_shadow_local_lights,
|
|
Rt_shadow_bias_min,
|
|
Rt_shadow_bias_max,
|
|
Rt_shadow_samples_override,
|
|
Sun_angular_size_override,
|
|
Rtao_samples,
|
|
Shadow_contact_hardening_enabled};
|
|
Lab_settings_saved = true;
|
|
}
|
|
|
|
void lab_close(bool reset) {
|
|
if (Lab_settings_saved) {
|
|
Shadow_render_method = Lab_saved_settings.shadow_render_method;
|
|
Rt_shadow_quality = Lab_saved_settings.rt_shadow_quality;
|
|
Max_rt_shadow_lights = Lab_saved_settings.max_rt_shadow_lights;
|
|
Max_rt_shadow_local_lights = Lab_saved_settings.max_rt_shadow_local_lights;
|
|
Rt_shadow_bias_min = Lab_saved_settings.rt_shadow_bias_min;
|
|
Rt_shadow_bias_max = Lab_saved_settings.rt_shadow_bias_max;
|
|
Rt_shadow_samples_override = Lab_saved_settings.rt_shadow_samples_override;
|
|
Sun_angular_size_override = Lab_saved_settings.sun_angular_size_override;
|
|
Rtao_samples = Lab_saved_settings.rtao_samples;
|
|
Shadow_contact_hardening_enabled = Lab_saved_settings.shadow_contact_hardening_enabled;
|
|
Lab_settings_saved = false;
|
|
}
|
|
|
|
if (reset) {
|
|
LMGR.reset();
|
|
}
|
|
gameseq_post_event(GS_EVENT_PREVIOUS_STATE);
|
|
}
|
|
|
|
void lab_do_frame(float frametime) {
|
|
getLabManager()->onFrame(frametime);
|
|
}
|
|
|