extract scalign logic to a separate function

Author: mateuszJS

src/logic/index.zig

@@ -673,29 +673,21 @@ pub fn updateCache() void {
                         1 / shared.render_scale,
                         true,
                     );
-                    const init_width = bounds[0].distance(bounds[1]) * shared.render_scale; // * shared.render_scale to revert to logical scale, nothing screen/camera/zoom related
-                    const initial_size = texture_size.get_size(bounds);
-                    const init_cache_scale = initial_size.w / init_width;
 
-                    // Cost control: scale down texture if blur cost is too high
-                    const initial_sigma = types.Point{
-                        .x = filter.gaussianBlur.x * init_cache_scale,
-                        .y = filter.gaussianBlur.y * init_cache_scale,
-                    };
-                    const size, const sigma = texture_size.get_safe_blur_dims(
-                        initial_size,
-                        initial_sigma,
+                    const size, const sigma, const cache_scale = texture_size.get_safe_blur_dims(
+                        bounds,
+                        filter.gaussianBlur,
                     );
 
                     if (size.w < 1.001 or size.h < 1.001) continue;
                     // just to make sure device.createTexture won't round number down to 0
 
-                    shape.cache_scale = size.w / init_width;
+                    shape.cache_scale = cache_scale;
 
                     const extra_padding = shape.getFilterMargin();
                     const scaled_extra_padding = types.Point{
-                        .x = extra_padding.x * shape.cache_scale,
-                        .y = extra_padding.y * shape.cache_scale,
+                        .x = extra_padding.x * cache_scale,
+                        .y = extra_padding.y * cache_scale,
                     };
                     const bb = bounding_box.BoundingBox{
                         .min_x = -scaled_extra_padding.x,

src/logic/texture_size.zig

@@ -42,30 +42,36 @@ pub fn get_size(bounds: [4]PointUV) TextureSize {
 }
 
 const MAX_COST = 90050924; // it's just chosen base on my own preferences
-// returns new safe size and new sigma
-pub fn get_safe_blur_dims(tex_size: TextureSize, scaled_sigma: Point) struct { TextureSize, Point } {
+// returns new safe size, new sigma and cache scale
+pub fn get_safe_blur_dims(bounds: [4]PointUV, gaussianBlur: Point) struct { TextureSize, Point, f32 } {
+    var size = get_size(bounds);
+    const init_width = bounds[0].distance(bounds[1]) * shared.render_scale; // * shared.render_scale to revert to logical scale, nothing screen/camera/zoom related
+
+    const init_cache_scale = size.w / init_width;
+    var sigma = Point{
+        .x = gaussianBlur.x * init_cache_scale,
+        .y = gaussianBlur.y * init_cache_scale,
+    };
 
     // Cost control: scale down texture if blur cost is too high
-    var new_sigma = Point{ .x = scaled_sigma.x, .y = scaled_sigma.y };
     // in the future would be nice to measure speed of the blur and base on that calculate MAX_COST
-    var new_tex_size = TextureSize{ .w = tex_size.w, .h = tex_size.h };
-    const pixels = tex_size.w * tex_size.h;
-    const cost = 3 * new_sigma.x * pixels + 3 * new_sigma.y * pixels;
+    const pixels = size.w * size.h;
+    const cost = 3 * sigma.x * pixels + 3 * sigma.y * pixels;
 
     if (cost > MAX_COST) {
         const scale_down = std.math.pow(f32, cost / MAX_COST, 1.0 / 3.0); // Cube root
-        new_tex_size.w /= scale_down;
-        new_tex_size.h /= scale_down;
+        size.w /= scale_down;
+        size.h /= scale_down;
 
         // Scale both texture and sigma proportionally
-        new_sigma.x /= scale_down;
-        new_sigma.y /= scale_down;
+        sigma.x /= scale_down;
+        sigma.y /= scale_down;
 
         // Verify new cost
         // const new_pixels = size.w * size.h;
         // const new_cost = 3 * sigma_x * new_pixels + 3 * sigma_y * new_pixels;
         // std.debug.print("prev cost: {d}\n new cost: {d}\n   target: {d}\n", .{ cost, new_cost, MAX_COST });
     }
 
-    return .{ new_tex_size, new_sigma };
+    return .{ size, sigma, size.w / init_width };
 }