feat(vulkan): vulkan 1.4 core with the user interface and the launcher, shaders split into ogl46/vk14 with SPIR-V binaries loaded first

shaders/ogl46/common.glsl

@@ -0,0 +1,322 @@
+// what the shaders of the opengl 4.6 renderer share: the settings, the constants of the game, the lights, the clusters, the
+// blocks of the scene and of the model being drawn. the constants below are the values of the game (gl/ubo.h and others):
+// compiled from the source, the game puts its own values before the source (gl::glsl_common) and they are taken instead;
+// the SPIR-V binaries (shaders/ogl46bin) are compiled with the values written here, so they have to stay the same as in the
+// game, which checks them when it starts (and doesn't load the binaries when they differ).
+//
+// the locations of the inputs and outputs between the stages, the same for a name in every shader (SPIR-V links the stages by
+// the locations, not by the names): 0 f_normal, 1 f_normal_raw, 2 f_coord, 3 f_pos, 4 f_clip_pos, 5 f_clip_future_pos,
+// 6 TangentFragPos, 7 UserData, 8-10 f_tbn, 11 f_model_draw, 12 f_albedo, 13 f_color, 14 f_coords, 15 f_local, 16 f_soft,
+// 17 f_streak, 18 g_coord, 19 g_coords, 20 g_pos
+#ifndef COMMON_GLSL
+#define COMMON_GLSL
+
+#if !defined(STAGE_VERTEX) && !defined(STAGE_FRAGMENT) && !defined(STAGE_GEOMETRY) && !defined(STAGE_COMPUTE)
+#error "the stage of the shader isn't defined: #define STAGE_VERTEX 1 (STAGE_FRAGMENT, STAGE_GEOMETRY, STAGE_COMPUTE) before the include of common.glsl"
+#endif
+
+#include "settings.glsl"
+
+#ifndef MASZYNA_CONSTANTS
+#define MASZYNA_CONSTANTS 1
+#define MAX_LIGHTS 1024U
+#define MAX_CASCADES 3U
+#define MAX_PARAMS 3U
+#define SHADOW_TEX 8
+#define ENV_TEX 9
+#define HEADLIGHT_TEX 10
+#define ENV_GGX_TEX 11
+#define SCENE_UBO_BINDING 0
+#define MODEL_UBO_BINDING 1
+#define INSTANCE_SSBO_BINDING 8
+#define INSTANCE_RECORD_SSBO_BINDING 9
+#define INSTANCE_JOB_SSBO_BINDING 10
+#define INSTANCE_GROUP_SSBO_BINDING 11
+#define INSTANCE_LOD_SSBO_BINDING 12
+#define INSTANCE_COUNTER_SSBO_BINDING 13
+#define INSTANCE_OUTPUT_SSBO_BINDING 14
+#define INSTANCE_COMMAND_SSBO_BINDING 15
+#define MODEL_DRAW_SSBO_BINDING 10
+#define INSTANCE_CULL_GROUP_SIZE 64
+#define INSTANCE_OFFSETS_GROUP_SIZE 1024
+#define INSTANCE_COMMAND_GROUP_SIZE 64
+#define HIZ_GROUP_SIZE 8
+#define SHADOW_FIT_GROUP_SIZE 16
+#define SHADOW_FIT_SSBO_BINDING 9
+#define PARTICLE_GROUP_SIZE 64
+#define PARTICLE_SSBO_BINDING 9
+#define PARTICLE_SOURCE_SSBO_BINDING 10
+#define PARTICLE_OWNER_SSBO_BINDING 11
+#define PARTICLE_OUTPUT_SSBO_BINDING 12
+#define PARTICLE_COMMAND_SSBO_BINDING 13
+#define INSTANCE_COUNTER_HEADER 8
+#define INSTANCE_JOB_SLEEPERS 1U
+#define LIGHT_SSBO_BINDING 0
+#define CLUSTER_GRID_X 16
+#define CLUSTER_GRID_Y 9
+#define CLUSTER_GRID_Z 24
+#define CLUSTER_COUNT 3456
+#define MAX_LIGHTS_PER_CLUSTER 64
+#define CLUSTER_BUILD_GROUP_SIZE 64
+#define CLUSTER_CULL_GROUP_SIZE 64
+#define CLUSTER_UBO_BINDING 2
+#define CLUSTER_AABB_SSBO_BINDING 1
+#define CLUSTER_RANGE_SSBO_BINDING 2
+#define CLUSTER_INDEX_SSBO_BINDING 3
+#define CLUSTER_COUNTER_SSBO_BINDING 4
+#define ENVMAP_GGX_LEVELS 7
+#define ENVMAP_GGX_ROUGHNESS_MIN 0.200000
+#define ENVMAP_GGX_GROUP_SIZE 8
+#define SKY_SSBO_BINDING 5
+#define EXPOSURE_SSBO_BINDING 6
+#define EXPOSURE_HISTOGRAM_BINS 256
+#define EXPOSURE_HISTOGRAM_GROUP_SIZE 16
+#define ATMOSPHERE_UBO_BINDING 4
+#define ATMOSPHERE_RESULT_SSBO_BINDING 7
+#define ATMOSPHERE_TRANSMITTANCE_WIDTH 256
+#define ATMOSPHERE_TRANSMITTANCE_HEIGHT 64
+#define ATMOSPHERE_MULTISCATTERING_SIZE 32
+#define ATMOSPHERE_SKYVIEW_WIDTH 192
+#define ATMOSPHERE_SKYVIEW_HEIGHT 108
+#define ATMOSPHERE_AMBIENT_GROUP_SIZE 256
+#define ATMOSPHERE_TRANSMITTANCE_UNIT 0
+#define ATMOSPHERE_MULTISCATTERING_UNIT 1
+#define ATMOSPHERE_SKYVIEW_UNIT 2
+#define SKY_VIEW_TEX 12
+#define LOCAL_SHADOW_TEX 13
+#define LOCAL_SHADOW_LAMPS_TEX 14
+#define HEADLIGHT_SHADOW_TEX 15
+#define MAX_HEADLIGHT_SHADOWS 4U
+#define FOG_VOLUME_TEX 16
+#define CLOUD_SHADOW_TEX 17
+#define CLOUD_TEX 18
+#define CLOUD_SHAPE_TEX 19
+#define CLOUD_DETAIL_TEX 20
+#define CLOUD_COVERAGE_TEX 21
+#define CLOUD_HISTORY_TEX 22
+#define SCENE_DEPTH_TEX 23
+#define WEATHER_UBO_BINDING 5
+#define WEATHER_SCRATCH_SSBO_BINDING 9
+#define MAX_CLOUD_LAYERS 4
+#define FOG_HORIZON_SAMPLES 32
+#define WEATHER_GROUP_SIZE 8
+#define FOG_VOLUME_BIAS 10.000000
+#endif
+
+const uint LIGHT_SPOT = 0U;
+const uint LIGHT_POINT = 1U;
+const uint LIGHT_DIR = 2U;
+const uint LIGHT_HEADLIGHTS = 3U;
+
+struct light_s
+{
+        vec3 pos;
+        uint type;
+
+        vec3 dir;
+        float in_cutoff;
+
+        vec3 color;
+        float out_cutoff;
+
+        float linear;
+        float quadratic;
+
+        float intensity;
+        float ambient;
+
+        mat4 headlight_projection;
+        vec4 headlight_weights;
+};
+
+// storage blocks are guaranteed only in fragment and compute shaders (GL 4.6 minimum for the other stages is 0)
+#if defined(STAGE_FRAGMENT) || defined(STAGE_COMPUTE)
+layout(std430, binding = LIGHT_SSBO_BINDING) readonly buffer light_ssbo
+{
+        vec3 ambient;
+        // lights stored in lights[], what the cluster culling goes through
+        uint lights_total;
+
+        vec3 fog_color;
+        // lights the shading loop goes through when the lights are not clustered
+        uint lights_count;
+        // 1 if the shading takes the lights from the list of the cluster of a fragment, see cluster_ubo
+        uint lights_clustered;
+        // scale of the directional part of the sky ambient light, see sky_ssbo
+        float sky_ambient_factor;
+        // 1 if rough reflections come from the prefiltered environment map
+        uint env_ggx;
+
+        light_s lights[];
+};
+
+// directional part of the sky ambient light: real spherical harmonics (bands 1 and 2, band 0 is ambient) of the light
+// a surface facing a world space direction gets, in units of ambient. see gl::sky_data
+layout(std430, binding = SKY_SSBO_BINDING) readonly buffer sky_ssbo
+{
+        vec4 sky_ambient_sh[9];
+};
+#endif
+
+// light clusters, see gl/cluster_grid.h
+struct cluster_aabb_s
+{
+        vec4 lower;
+        vec4 upper;
+};
+
+struct cluster_range_s
+{
+        uint offset;
+        uint count;
+};
+
+#if defined(STAGE_FRAGMENT) || defined(STAGE_COMPUTE)
+// parameters of the grid for the pass being drawn
+layout(std140, binding = CLUSTER_UBO_BINDING) uniform cluster_ubo
+{
+        mat4 cluster_projection;
+        float cluster_znear;
+        float cluster_zfar;
+        float cluster_slice_scale;
+        float cluster_slice_bias;
+        vec2 cluster_viewport_size;
+        uint cluster_valid;
+};
+
+// the compute passes fill the cluster buffers, shading only reads them
+#ifdef STAGE_COMPUTE
+#define CLUSTER_SSBO_ACCESS
+layout(std430, binding = CLUSTER_AABB_SSBO_BINDING) buffer cluster_aabb_ssbo
+{
+        cluster_aabb_s cluster_aabbs[];
+};
+
+layout(std430, binding = CLUSTER_COUNTER_SSBO_BINDING) buffer cluster_counter_ssbo
+{
+        uint cluster_index_count;
+        uint cluster_overflow_count;
+};
+#else
+#define CLUSTER_SSBO_ACCESS readonly
+#endif
+
+layout(std430, binding = CLUSTER_RANGE_SSBO_BINDING) CLUSTER_SSBO_ACCESS buffer cluster_range_ssbo
+{
+        cluster_range_s cluster_ranges[];
+};
+
+layout(std430, binding = CLUSTER_INDEX_SSBO_BINDING) CLUSTER_SSBO_ACCESS buffer cluster_index_ssbo
+{
+        uint cluster_light_indices[];
+};
+#endif
+
+#ifdef MODEL_DRAWS
+// programs of the multi draws of the instances drawn from the gpu culling: the model block of every draw comes from a
+// storage buffer, picked by the number of the draw in the multi draw. the fragment stage gets the number from the vertex
+// stage (which writes f_model_draw), and the names of the uniform block below stand for the fields of the draw
+struct model_draw_s
+{
+        mat4 modelview;
+        mat3 modelviewnormal;
+        vec4 param[MAX_PARAMS];
+
+        mat4 future;
+        float opacity;
+        float emission;
+        float fog_density;
+        float alpha_mult;
+        float shadow_tone;
+};
+
+layout(std430, binding = MODEL_DRAW_SSBO_BINDING) readonly buffer model_draw_ssbo
+{
+        model_draw_s model_draws[];
+};
+
+#if defined(STAGE_VERTEX)
+layout(location = 11) flat out uint f_model_draw;
+#define MODEL_DRAW gl_DrawID
+#elif defined(STAGE_FRAGMENT)
+layout(location = 11) flat in uint f_model_draw;
+#define MODEL_DRAW f_model_draw
+#else
+#define MODEL_DRAW 0
+#endif
+
+#define modelview model_draws[MODEL_DRAW].modelview
+#define modelviewnormal model_draws[MODEL_DRAW].modelviewnormal
+#define param model_draws[MODEL_DRAW].param
+#define future model_draws[MODEL_DRAW].future
+#define opacity model_draws[MODEL_DRAW].opacity
+#define emission model_draws[MODEL_DRAW].emission
+#define fog_density model_draws[MODEL_DRAW].fog_density
+#define alpha_mult model_draws[MODEL_DRAW].alpha_mult
+#define shadow_tone model_draws[MODEL_DRAW].shadow_tone
+#else
+layout(std140, binding = MODEL_UBO_BINDING) uniform model_ubo
+{
+        mat4 modelview;
+        mat3 modelviewnormal;
+        vec4 param[MAX_PARAMS];
+
+        mat4 future;
+        float opacity;
+        float emission;
+        float fog_density;
+        float alpha_mult;
+        float shadow_tone;
+};
+#endif
+
+layout(std140, binding = SCENE_UBO_BINDING) uniform scene_ubo
+{
+    mat4 projection;
+    mat4 inv_view;
+    mat4 lightview[MAX_CASCADES];
+    vec3 cascade_end;
+    float time;
+    vec4 rain_params;
+    vec4 wiper_pos;
+    vec4 wiper_timer_out;
+    vec4 wiper_timer_return;
+    // shadow maps of the headlights, see gl::scene_ubs
+    mat4 headlight_shadow[MAX_HEADLIGHT_SHADOWS];
+    vec4 headlight_shadow_params[MAX_HEADLIGHT_SHADOWS];
+    // contact shadows, see gl::scene_ubs
+    vec4 contact_shadow_params;
+    vec4 contact_shadow_lamps;
+    // cascades of the sun shadows fitted to the depth of the view, see gl::scene_ubs
+    vec4 shadow_fit;
+};
+
+#ifdef STAGE_VERTEX
+// Per-instance modelview matrices for GPU-instanced draws, element 0 is identity.
+// Draws which aren't instanced have gl_BaseInstance == 0 and gl_InstanceID == 0,
+// so effective_modelview() reduces to model_ubo.modelview. For instanced draws
+// the C++ side uploads camera-space root transforms of the instances and draws
+// them from base instance onwards, with model_ubo.modelview set to the submodel-local
+// chain (computed from identity, NOT from the camera/instance), so the product
+// gives the correct final transform per instance per submodel.
+layout(std430, binding = INSTANCE_SSBO_BINDING) readonly buffer instance_ssbo
+{
+    mat4 instance_modelview[];
+};
+
+mat4 effective_modelview() {
+    return instance_modelview[gl_BaseInstance + gl_InstanceID] * modelview;
+}
+mat3 effective_modelviewnormal() {
+    // instance_modelview can include per-instance scale (uniform or per-axis),
+    // so its upper-3x3 is NOT its own inverse-transpose in the non-uniform
+    // case. Compute the correct normal matrix via transpose(inverse(...)).
+    // For pure rotation+translation this still produces the rotation matrix
+    // (one extra mat3 inverse per vertex — modern GPUs handle it cheaply).
+    mat3 instance_mv3 = mat3(instance_modelview[gl_BaseInstance + gl_InstanceID]);
+    mat3 instance_normal = transpose(inverse(instance_mv3));
+    return instance_normal * modelviewnormal;
+}
+#endif
+
+#endif