4 files changed, 53 insertions, 9 deletions
diff --git a/adapters/fparkan-render-vulkan/shaders/triangle.frag b/adapters/fparkan-render-vulkan/shaders/triangle.frag
index 6a6e752..b945905 100644
--- a/adapters/fparkan-render-vulkan/shaders/triangle.frag
+++ b/adapters/fparkan-render-vulkan/shaders/triangle.frag
@@ -9,12 +9,15 @@ layout(location = 5) in vec3 in_base_diffuse;
 layout(location = 6) in vec3 in_base_specular;
 layout(location = 7) in vec3 in_overlay_diffuse;
 layout(location = 8) in vec3 in_overlay_specular;
+layout(location = 9) in vec3 in_world_position;
 layout(location = 0) out vec4 out_color;
 
 layout(set = 0, binding = 0) uniform sampler2D base_color;
 layout(set = 0, binding = 1) uniform sampler2D base_detail;
 layout(set = 0, binding = 2) uniform sampler2D overlay_color;
 layout(set = 0, binding = 3) uniform sampler2D overlay_detail;
+layout(set = 1, binding = 0) uniform sampler2D reflection_color;
+layout(set = 1, binding = 1) uniform sampler2D embm_bump;
 
 layout(std140, set = 0, binding = 4) uniform FrameConstants {
     mat4 clip_from_world;
@@ -28,6 +31,8 @@ layout(std140, set = 0, binding = 4) uniform FrameConstants {
     vec4 fog_color;
     vec4 fog_distances;
     vec4 camera_position;
+    vec4 embm_bounds;
+    vec4 embm_wave;
 } frame;
 
 layout(push_constant) uniform MaterialConstants {
@@ -66,8 +71,39 @@ layout(push_constant) uniform MaterialConstants {
 } material;
 
 void main() {
+    int mode = int(round(material.material_mode));
+    if ((mode & 32) != 0 && (mode & 4) == 0 && in_world_position.z < frame.camera_position.w) {
+        discard;
+    }
     vec2 base_uv = vec2(material.base_page_x, material.base_page_y)
         + in_uv * vec2(material.base_page_w, material.base_page_h);
+    if ((mode & (64 | 256)) != 0) {
+        vec2 reflection_uv = gl_FragCoord.xy / vec2(textureSize(reflection_color, 0));
+        vec2 span = frame.embm_bounds.zw - frame.embm_bounds.xy;
+        vec2 plane_uv = vec2(1.0) - (in_world_position.yx - frame.embm_bounds.yx) / span.yx;
+        vec2 bump_uv = plane_uv * frame.embm_wave.y + frame.embm_wave.x;
+        vec2 duv = max(vec2(-1.0), (texture(embm_bump, bump_uv).rg * 255.0 - 128.0) / 127.0);
+        vec2 displacement = duv * frame.embm_wave.zw;
+        if ((mode & 128) != 0) {
+            reflection_uv = plane_uv + displacement;
+        } else {
+            // shortcut: non-perspective API cameras retain the projective mirror fallback.
+            vec3 displaced_world = in_world_position - vec3(displacement.yx * span, 0.0);
+            vec4 displaced_clip = frame.clip_from_world * vec4(displaced_world, 1.0);
+            if (displaced_clip.w > 0.000001) {
+                reflection_uv = displaced_clip.xy / displaced_clip.w * 0.5 + 0.5;
+            }
+        }
+        vec3 water_color = (mode & 256) != 0
+            ? texture(base_color, base_uv).rgb
+            : texture(reflection_color, reflection_uv).rgb;
+        vec3 rgb = water_color * in_base_diffuse + in_base_specular;
+        out_color = vec4(mix(rgb * in_color, frame.fog_color.rgb, in_fog_factor), material.diffuse_alpha);
+        if (out_color.a < material.alpha_cutoff) {
+            discard;
+        }
+        return;
+    }
     vec2 detail_uv = vec2(material.detail_page_x, material.detail_page_y)
         + in_detail_uv * vec2(material.detail_page_w, material.detail_page_h);
     vec2 overlay_uv = vec2(material.overlay_page_x, material.overlay_page_y)
@@ -78,7 +114,6 @@ void main() {
     vec4 detail = texture(base_detail, detail_uv);
     vec4 overlay = texture(overlay_color, overlay_uv);
     vec4 overlay_detail_sample = texture(overlay_detail, overlay_detail_uv);
-    int mode = int(round(material.material_mode));
     int combiner_mode = mode & 3;
 
     // Native sky mode 4 combines nebula and stars as
diff --git a/adapters/fparkan-render-vulkan/shaders/triangle.frag.spv b/adapters/fparkan-render-vulkan/shaders/triangle.frag.spv
index 7b7c3da..02596d1 100644
--- a/adapters/fparkan-render-vulkan/shaders/triangle.frag.spv
+++ b/adapters/fparkan-render-vulkan/shaders/triangle.frag.spv
diff --git a/adapters/fparkan-render-vulkan/shaders/triangle.vert b/adapters/fparkan-render-vulkan/shaders/triangle.vert
index d1e2e04..3accd2e 100644
--- a/adapters/fparkan-render-vulkan/shaders/triangle.vert
+++ b/adapters/fparkan-render-vulkan/shaders/triangle.vert
@@ -19,6 +19,7 @@ layout(location = 5) out vec3 out_base_diffuse;
 layout(location = 6) out vec3 out_base_specular;
 layout(location = 7) out vec3 out_overlay_diffuse;
 layout(location = 8) out vec3 out_overlay_specular;
+layout(location = 9) out vec3 out_world_position;
 
 layout(std140, set = 0, binding = 4) uniform FrameConstants {
     mat4 clip_from_world;
@@ -32,6 +33,8 @@ layout(std140, set = 0, binding = 4) uniform FrameConstants {
     vec4 fog_color;
     vec4 fog_distances;
     vec4 camera_position;
+    vec4 embm_bounds;
+    vec4 embm_wave;
 } frame;
 
 layout(std430, set = 0, binding = 5) readonly buffer MaterialSpecular {
@@ -42,7 +45,8 @@ layout(std430, set = 0, binding = 5) readonly buffer MaterialSpecular {
 struct PointLightRecord {
     vec4 position_range;
     vec4 rgb_active;
-    vec4 coefficients_active;
+    vec3 coefficients;
+    uint owner_scope;
 };
 
 layout(std430, set = 0, binding = 6) readonly buffer PointLightBuffer {
@@ -130,12 +134,13 @@ float native_specular_power(float cosine, float power) {
 }
 
 float native_fog_factor(vec3 world_position) {
-    float fog_span = frame.fog_distances.y - frame.fog_distances.x;
-    float distance_to_camera = distance(world_position, frame.camera_position.xyz);
-    if (fog_span <= 0.000001 || distance_to_camera <= frame.fog_distances.x) {
+    float fog_span_squared = frame.fog_distances.w - frame.fog_distances.z;
+    vec3 to_camera = world_position - frame.camera_position.xyz;
+    float distance_squared = dot(to_camera, to_camera);
+    if (fog_span_squared <= 0.000001 || distance_squared <= frame.fog_distances.z) {
         return 0.0;
     }
-    return clamp((distance_to_camera - frame.fog_distances.x) / fog_span, 0.0, 1.0);
+    return clamp((distance_squared - frame.fog_distances.z) / fog_span_squared, 0.0, 1.0);
 }
 
 vec3 normalized_or(vec3 value, vec3 fallback) {
@@ -193,6 +198,9 @@ LightingTerms native_material_lighting(
     }
     for (uint index = 0u; index < point_light_buffer.header.x; ++index) {
         PointLightRecord point_light = point_light_buffer.records[index];
+        if (point_light.owner_scope != 0u && point_light.owner_scope != uint(gl_InstanceIndex)) {
+            continue;
+        }
         vec3 to_light = point_light.position_range.xyz - world_position;
         float distance_squared = dot(to_light, to_light);
         float range = point_light.position_range.w;
@@ -205,9 +213,9 @@ LightingTerms native_material_lighting(
             float ndotl = dot(normal, light_direction);
             if (ndotl > 0.0) {
                 float t = (range - distance_to_light) / range;
-                float attenuation = point_light.coefficients_active.x
-                    + point_light.coefficients_active.y * t
-                    + point_light.coefficients_active.z * t * t;
+                float attenuation = point_light.coefficients.x
+                    + point_light.coefficients.y * t
+                    + point_light.coefficients.z * t * t;
                 attenuation = max(attenuation, 0.0);
                 accumulated += ndotl * directional_rgb * point_light.rgb_active.rgb * attenuation;
                 specular += specular_from_light(
@@ -240,6 +248,7 @@ LightingTerms native_material_lighting(
 }
 
 void main() {
+    out_world_position = in_position;
     out_color = in_color;
     out_uv = in_uv;
     out_detail_uv = in_detail_uv;
diff --git a/adapters/fparkan-render-vulkan/shaders/triangle.vert.spv b/adapters/fparkan-render-vulkan/shaders/triangle.vert.spv
index f74b1f8..74adcc7 100644
--- a/adapters/fparkan-render-vulkan/shaders/triangle.vert.spv
+++ b/adapters/fparkan-render-vulkan/shaders/triangle.vert.spv