The vertical FOV does not change with aspect ratio. The horizontal FOV gets wider as the aspect ratio increases. The FOV slider increases both vertical and horizontal FOV the same. A 360° rotation contains 8000 units, regardless of resolution. More generally: A 360° rotation takes 8000/ratio units, where ratio is the current FOV divided by hipfire FOV. Number of units required to reach the edge of the screen (classic normalization vs none; FOV slider maxed, so the FOV values are actually 65*1.4 or FOV*1.2): 4:3 resolution (1024x768 and 1600x1200 yield the same results): 65: 1010 => 360° needs ~8 of these turns. This makes sense because the FOV is 91°, so each turn is 45.5°. 40: 1010 532 => 15 turns needed 20: 1010 266 => 30 turns needed 16:10 (1920x1200): 65: 1127 40: 1180 624 20: 1200 318 16:9 (1600x900 and 1920x1080, basically the same results): 65: 1190 40: 1293 680 20: 1330 351 For 4:3 resolution, everything is fine: The units to reach the edge of the screen remain constant, regardless of FOV. For other resolutions, the horizontal FOV does not match the expected values anymore (i.e. the game indeed seems to be based on 4:3 resolutions).

function MenuManager:set_mouse_sensitivity(zoomed) self._controller:get_setup():get_connection("look"):set_multiplier(self._look_multiplier) -- Handle sensitivity via _pc_look_function. managers.controller:rebind_connections() local sens = managers.user:get_setting("camera_sensitivity") local xsens = sens local ysens = sens local s = math.clamp(managers.user:get_setting("camera_zoom_sensitivity"),0.001,1) * 3/4 if zoomed and alive(managers.player:player_unit()) then local currentState = managers.player:player_unit():movement():current_state() if alive(currentState._equipped_unit) then local fovMul = managers.user:get_setting("fov_multiplier") local aspectRatio = managers.viewport:aspect_ratio() local hip = math.tan(32.5*fovMul) local ads = math.tan((currentState._equipped_unit:base():zoom() or 65)*(fovMul+1)/4) xsens = xsens * math.atan(s * aspectRatio * ads) / math.atan(s* aspectRatio * hip) ysens = ysens * math.atan(s * ads) / math.atan(s * hip) end end MenuManager.xsens = xsens MenuManager.ysens = ysens end function FPCameraPlayerBase:_pc_look_function(stick_input, stick_input_multiplier, dt) mvector3.set_x(stick_input, (MenuManager.xsens or 1)*stick_input.x) mvector3.set_y(stick_input, (MenuManager.ysens or 1)*stick_input.y) return stick_input.x, stick_input.y end

Let fv = FOV/2 in whatever context it may pop up (it makes sense, because it has half the letters, 1.5 rounded to 2). All calculations revolve around this identity: tan fv = w/d where w is the half the (physical) width of the screen (h is also possible, referring to height) d is the (physical) distance of your head to the screen. It's rather abstract and thus eliminated from equations. The FOV slider and zoom in the game refer to the horizontal FOV given a 4:3 ratio. The game is set up in such a way that the vertical FOV is independent of aspect ratio. So the first step for the horizontal FOVs of other aspect ratios is to calculate the vertical fv (fvy): Let fv43 = horizontal fv given 4:3 ratio, i.e. essentially what the FOV slider and weapon sights modify. w43 and h43 = physical width or height of a 4:3 screen. These are abstract quantities on their own because they could refer to any screen width or height. tan fv43 = w43/d <=> 1/d = tan(fv43)/w43 => tan fvy = h43/d = h43/w43 tan(fv43) = 3/4 tan(fv43) fvy is the same regardless of aspect ratio. It depends solely on fv43, and fv43 is known, so fvy is known. fv43 is the only quantity that the user can influence, by moving the slider or using weapon sights. ==> tan fvy = 3/4 tan(fv43) Calculate the horizontal fv (fvx): Start with arbitrary width w, height h and distance d. 1/d = tan(fvy)/h = 3/4 tan(fv43)/h => tan fvx = w/d = w/h 3/4 tan(fv43) fvx depens on fv43 and the aspect ratio (w/h), both of which are known. ==> tan fvx = w/h 3/4 tan(fv43) Ingame slider and zoom: The slider and zoom change fv43. Hipfire: fv43 = 65 degrees, multiplied by 1.0 to 1.4 depending on slider. Sights: fv43 = 63, 60, 55, ... 20 degrees, multiplied by 1.0 to 1.2 depending on slider. Normalization: Let inp = mouse input, translated into degrees hip = fv when not using sights ads = fv when using sights Consider a point exactly halfway between the center and right edge of the screen. Given an fv of 40 degrees, what is the rotation required to aim at that point? tan inp = s/d where s is the distance from center (50% of the screen width in this case) tan fv = w/d => tan inp / tan fv = s/w w is unnecessary if we treat s as a dimensionless percentage or fraction. Drop w. s = tan inp / tan fv <=> inp = atan(s tan fv) So in this case, inp = 22.76 degrees. Normalization works as follows: For a certain s, make sure that the required input to reach that s is the same regardless of FOV. inp_hip = atan(s tan hip) inp_ads = atan(s tan ads) inp_hip is the plain, unmodified input. We want to modify inp_hip so that it becomes inp_ads. inp_hip * norm = inp_ads <=> norm = inp_ads/inp_hip = atan(s tan ads) / atan(s tan hip) So just multiply the normal input by norm to get the ads input. Special cases: Classic normalization (screen edge; s=1): norm = ads/hip Delta normalization (infinitely small; s=0): atan(s tan ads) / atan(s tan hip) \s->0 -> 0/0 Hopital rule: d/dx atan(s) = 1/(1+s^2) d/dx atan(s c) = c/(1 + c^2 s^2) = tan(ads)/(1+ tan(ads)^2 s^2) / tan(hip) * (1+ tan(hip)^2 s^2) \ s->0 = tan(ads)/tan(hip) *(1+tan(hip)^2 s^2)/(1+tan(ads)^2 s^2) \ s->0 = tan(ads)/tan(hip) *(1+0) / (1+0) = tan(ads)/tan(hip) norm = tan(ads)/tan(hip) ==> norm = atan(s tan ads) / atan(s tan hip) Double normalization: x and y should be normalized independently. Reminder: tan fvx = 3/4 tan(fv43) w/h => fvx = atan(3/4 tan(fv43) w/h) tan fvy = 3/4 tan(fv43) => fvy = atan(3/4 tan(fv43)) norm = atan(s tan ads) / atan(s tan hip) Consider the case s=1, 16:10 with hip=65, ads=20 (slider at 1.0): hipx = atan(3/4 tan(65) 16/10) = 68.76 adsx = atan(3/4 tan(20) 16/10) = 23.59 hipy = atan(3/4 tan(65)) = 58.13 adsy = atan(3/4 tan(20)) = 15.27 norm = ads/hip normx = adsx / hipx = atan(3/4 tan(20) 16/10) / atan(3/4 tan(65) 16/10) = 0.34 normy = adsy / hipy = atan(3/4 tan(20)) / atan(3/4 tan(65)) = 0.26 It cannot work out with a common normalizer. There is no harm doing independent normalization, so do it. Shifting FOV proportions: The data from double normalization also shows that the fvy/fvx ratios change: hipx/hipy = 68.76/58.13 = 1.18 adsx/adsy = 23.59/15.27 = 1.54 For small FOVs, the ratio approaches the aspect ratio (16:10, i.e. 1.6). For FOVs close to 180, the ratio approaches 1.0. Consider classic normalization with 16:10: For small FOVs, it takes 16 units to reach the right edge of the screen and 10 units to reach the top. For large FOVs, it takes the same number of units to reach either edge. The most sensible option would be the aspect ratio as the goal. The curious part is that hipfire is then affected. The x sensitivity should probably stay unchanged to have the least impact. The y sensitivity should adjust for hipfire: It takes roughly the same number of units to reach either edge. x should take more units than y, but x sensitivity is fixed. So y must need less units. The y sensitivity should be increased. I haven't had any personal problems with hipfire however. If I did change this, I would probably have to add a separate y sensitivity multiplier option somewhere anyway. So do not adjust. Summary: fv = FOV/2 Only fv43 is controlled by the user: Hipfire: fv43 = 65 degrees, multiplied by 1.0 to 1.4 depending on slider. Sights: fv43 = 63, 60, 55, ... 20 degrees, multiplied by 1.0 to 1.2 depending on slider. w/h = aspect ratio tan fvx = 3/4 tan(fv43) w/h tan fvy = 3/4 tan(fv43) => Let hip = 65/2 * slider ads = 63, 60 ... 20 * (slider+1)/2 tan hipx = 3/4 tan(hip) w/h tan hipy = 3/4 tan(hip) tan adsx = 3/4 tan(ads) w/h tan adsy = 3/4 tan(ads) Let user define an s between 0.001 and 1, which is the distance from the center of the screen at which the normalization should work perfectly. A value of 0.001 essentially corresponds to a single pixel offset for a display with 1920 width. normx = atan(s tan adsx) / atan(s tan hipx) = atan(s 3/4 w/h tan(ads)) / atan(s 3/4 w/h tan(hip)) normy = atan(s tan adsy) / atan(s tan hipy) = atan(s 3/4 tan(ads)) / atan(s 3/4 tan(hip)) When using sights, the x input is multiplied by normx, y input by normy.