Drimzi

It's a problem with the converter. 86.631971 should be getting rounded down to 86, and that would give you 0.9889534884 instead.

If they are the same aspect ratio, then the 32in monitor will have 105.96 fov inside the 24.5" region of the screen.

There is less degrees on the screen (lower degree/pixel), so if you continue to rotate the same degree/count then you will rotate more pixels. You have to reduce the degree/count to rotate the same degree/pixels, and end up with a longer distance to rotate 360 degrees. Degree/pixels only uses the middle pixels. If you know there is a total of 103 degrees horizontally (Overwatch), which is across 1920 pixels, then you can scale that down to find how many there is in 1 pixel. 2 * atan(1/1920 * tan(103/2 * pi/180)) * 180/pi = ~0.075032 If you drop to 30 degrees vertically (Overwatch Widowmaker), then you end up with less degree/pixel. 2 * atan(1/1080 * tan(30/2 * pi/180)) * 180/pi = ~0.02843 Since the game rotates a fixed amount of degrees/count for each unit of sensitivity, you will want to reduce the sensitivity when you scope in (by ~0.028/0.075) to keep the same pixel ratio. When scoped, you will have to rotate ~38% of the original amount to preserve the sensitivity of the mouse, but you will end up with the inconvenience of a larger distance to turn 360 degrees. (2 * atan(1/1080 * tan(30/2 * pi/180)) * 180/pi) / (2 * atan(1/1920 * tan(103/2 * pi/180)) * 180/pi) = ~0.378909

Monitor distance 0% is also for 2d to 3d. The distance to move the cursor 1 pixel is the same distance to turn 1 pixel. If you measure the fov in the 4 adjacent middle pixels, you will turn half that.

It's not that complicated. It's all about the physical scale of the image you see. If the scale changes, then sensitivity changes as well and you need to adjust the cm/360 to fix it. Treat the monitor as a window that you look through. Think of the resolution, fov, and monitor as an image resizer. If any of these change the physical size of the image, then you need to change your cm/360 by the same amount (monitor distance 0%). You will need to change the cm/360 in these cases because they will change physical size of the game: Different fov on the same monitor Same fov on different sized monitors Reducing resolution without upscaling Changing aspect ratio in a horizontal fov game Start with 103 fov at 1080p If you reduce the resolution to 720p without upscaling it, then you have shrank the physical size of the image by 66.67% of the original size. You will want to reduce your cm/360 to 66.66% of the original value as well. This is identical to zooming out 1.5x to ~124 fov. (2 * atan(3/2 * tan(103/2 * pi/180)) * 180/pi = ~124). This shows that the resolution can be used as an FOV slider if you want, you just don't get to see the extra fov since its black. Here we change the fov to 162 fov. It is a 5x zoom difference. It practically shrank the image to 20% of the original, so your cm/360 needs to shrink to 20% of the original value as well. Here is 103 fov resized to 20%, overlayed on the 162 fov. If this monitor was 5x larger than the above, then there would be no need to change the cm/360. The physical size of the 103 fov area in yellow would be identical to the monitor above. Since the monitor is basically a window that you are looking through, the 5x bigger window provides the extra fov. Here is the 162 fov image resized 500%. You can see that it's identical to 103 fov. If you reduce the resolution width to go from 16:9 to 4:3, and it only crops off the sides, then there is no change to the physical size of the image and no change to the sensitivity. If the game uses horizontal fov though, and it tries to keep the 103 on 1440px instead of 1920px, then there is a 75% scale difference (1440/1920). So your cm/360 needs to be 75% of the original value as well. This 75% reduction results in an equivalent fov of ~118 (2 * atan(1920/1440 * tan(103/2 * pi/180)) * 180/pi).

2304x1440 was stretched horizontally by 1.111x, so you need to use 3456x1600. 2304 is 90% of 2560. 90% of 3840 is 3456. 3840 / 3456 = 10/9.

Ignore the ingame fov slider. Your actual horizontal 4:3 fov is 70 * cl_fovscale. This converts cl_fovScale to ingame fov slider, no idea why its like this but it shows you can just ignore the ingame slider value as it is nonsense: (cl_fovScale * 70)/0.9625 - 70/0.9625 + 70

MDV 177.78% with 90% scale.

The pixel ratio is the ratio between the amount you turn per count and how much fov there is in the centre pixels. The camera has to zoom in or out to achieve a different fov in the same area (otherwise its just cropping/extending), so thats going to affect how much fov there is in the centre pixels. To keep the same ratio the amount you turn also has to scale with the amount the camera zooms.

The apex legends fov slider doesnt show any decimals. You can slide it to multiple steps and it will still say 104, so you won't end up with exactly 104 (1.4675 cl_fovScale). You have to look at your config to get your true fov. Your value of 1.471401 is ~104.2836. So what you want to do is set up apex legends first, then open its config file and then transfer those values (because these are your true values) to aim lab to train your aim, or mouse-sensitivity to convert to other games. Here I set game units to config file, put in your values, and then flipped it back to in-game units. You can see the fov is not exactly 104, and its matching mouse-sensitivity's 360 distance on the scope, which scales from fov. If the fov was wrong it would scale to the ADS incorrectly. You can also use this calculator to see how buggy apex is https://jscalc.io/embed/Q1gf45VCY4tmm2dq

If you change the profile in Aim Lab it will set the fov to the default fov of that game. Aim Lab's default fov is 70 (102.45 horizontal), thats why you are getting 102 after you change profiles. Why are you changing profiles anyway? Just set the profile to Apex Legends and put in the values. The Angle of View values will only show 2 decimals and the cm/360 will only show 3 decimals, but other than that it is the same.

The windows pointer speed only affects your cursor and there is nothing wrong with reducing it. So if you want 1600 DPI, then you need to reduce your game sensitivity for rotations, and windows pointer speed for cursor.

I think this should work: https://www.desmos.com/calculator/trk3nrmtkp It calculates the amount of distortion there would be at the location of the cursor at a specific fov. This will become the cursor speed multiplier, simulating the distortion of 3D. You would need to make a script that can continuously get the cursors xy position, calculate the distortion amount and then feed that into RawAccel somehow. Before going through the effort I think the whole thing is quite pointless if the desktop itself isn't distorted. If it's flat then there is no context to the cursor speed change. The cursor and desktop panning is already behaving correct to the desktop's fov of 0. You aren't looking at your arbitrarily chosen fov so the cursor speed changes will feel random. If you were able to distort the desktop after it has rendered then the cursor would get distorted anyway. Edit: I did a quick test to verify that the distortion calculation was correct as i wasnt sure. It says the distortion/speed multiplier will be 2 when moving the cursor to the top or bottom of the screen (y 0 or 1080) at 90 vertical fov. So in Aim Lab's creator studio I set the fov to 90 and placed a pillar that begins at the cursor and ends at the exact top of the screen. The sphere at the original crosshair position gets distorted vertically by a factor of 2 (from 34px to only half of the sphere being 34px). I then changed to 150 vertical fov. The pillar was now 145 pixels tall instead of 540, which makes sense since 540 / tan(150/2 *pi/180) = 144.69. I looked up 145 pixels and the sphere again stretched vertically by a factor of 2 (from ~9px to ~18px). In the calculator if you set 150 fov and cursor y to 540 +- 145, you get 2, so it appears that my calculations were correct after all.

I think you're going about it wrong. You're trying to make the cursor behave weird instead of just panning the screen or making the desktop 3D. The distances are affected in 3D because there is distortion and curvature, so it makes no sense for the cursor to behave weird when the 2D desktop has neither. It's already behaving how it is supposed to. If you decrease the FOV, which decreases the distortion and curvature, you will see that the mouse characteristics already start to resemble 2D more and more as you approach 0 FOV. At 1 FOV any conversion method in the calculator (Jedi's Trick has to be set to 1:1 resolution) will approximately match the speed and distance of the cursor. If you want to simulate 3D aiming then you have to move the screen instead of the cursor (e.g. panning in a photo viewer, or playing mcOsu's original fps mod, not fposu). If you want the speed of the desktop, with the distances reflecting the distortion on the screen, then you just convert using 0%. It doesn't matter what FOV you convert to/from, the cursor will increment 1 pixel for each count, and the camera will rotate 1 center pixel's worth of degrees. The circumference of the 3D projection (the red sphere in your diagram) divided by the distance to travel the projection's circumference (the cm/360, and the orange sphere in your diagram), will be identical to the distance the cursor travels divided by the distance the hand/mouse travels.

The math would use square 1:1 dimensions, not the diagonal dimensions. That would eliminate aspect ratio.

Its the number of pixels the game window is occupying. So NIS doesnt affect anything since the game is still occupying 1920x1080 pixels. 23.5 to 24.5 is only a change of 4.25%. It would have felt off, but you would have gotten used to it pretty quickly I would imagine. - Your cursor should have felt 4.25% faster - Your game should have felt 4.25% faster - Your game would be 4.25% larger (a 4.25% zoom if you could view the 24.5" image through the 23.5") In an ideal world where mouse DPI was very granular, you could have decreased the DPI by 4.25% (you can technically do this with rawaccel). It would have corrected everything. The cursor speed, the rotation speed and the cm/360. The different cm/360 would still make it feel a little off though if you have learnt very specific mouse swipes for 90 degrees (turning corners) and 180 degrees (changing direction you are facing). 2.54 is to convert inch to cm.

I wouldn't bother going through the effort of converting your old sensitivity. You have already gotten used to your new sensitivity, and the change would have been small. Something like this for example: 24.5" to 27", still 90 4:3 fov, and still 1920x1080. Only variable that changed was the monitor size. On the 27" that 90 fov would be equivalent to 84 fov on the 24.5", which isnt what you played at. 90 fov on the 24.5" is equivalent to 96 fov on the 27", which also isnt what you are playing at. If you want to keep the same cm/360, you have to use 96 fov on the 27". Since you are still using 90 fov, you have to scale the cm/360 using focal lengths. You can find the change in focal length by simply comparing monitor size since thats the only variable that changed. 24.5/27 is the change in focal length. 10%. If it was fov instead, you would just compare fovs, using TAN(BeforeFOV/2 * PI/180) / TAN(AfterFOV/2 * PI/180), in this case you would do 84 and 90, or 90 and 96, both would also give 10%. This calculator is nice for visualising the focal length. It's showing the measurement in pixels though, for the physical measurement you need monitor size and resolution to figure out how large a pixel is. Screen size is diagonal, so you need diagonal resolution to get pixel size. Assuming a standard 240hz 1920x1080 24.5" monitor, playing Overwatch at 103 FOV 16:9 with 5 sensitivity and 800 Mouse DPI. DiagonalResolution (pixels) = SQRT(HorizontalResolution^2 + VerticalResolution^2) = SQRT(1920^2 + 1080^2) = 2202.9071700822983 PixelSize (cm) = (ScreenSize * 2.54) / DiagonalResolution = (24.5 * 2.54) / SQRT(1920^2 + 1080^2) = 0.02824903420586495 VerticalFOV (degrees) = (360 * ATAN(TAN(103/2 * PI/180) / (16/9))) / PI = 70.53280043291679 FocalLength (pixels) = (VerticalResolution/2) / TAN(VerticalFOV/2 * PI/180) = (1080/2) / TAN(((360 * ATAN(TAN(103/2 * PI/180) / (16/9))) / PI)/2 * pi/180) = 763.6184800011152 ProjectionRadius (cm) = FocalLength * PixelSize = ((1080/2) / TAN(((360 * ATAN(TAN(103/2 * PI/180) / (16/9))) / PI)/2 * pi/180)) * ((24.5 * 2.54) / SQRT(1920^2 + 1080^2)) = 21.571484561782103 ProjectionCircumference (cm) = ProjectionRadius * 2 * PI = (((1080/2) / TAN(((360 * ATAN(TAN(103/2 * PI/180) / (16/9))) / PI)/2 * pi/180)) * ((24.5 * 2.54) / SQRT(1920^2 + 1080^2))) * 2 * PI = 135.5376348526406 SensitivityCircumference (cm) = 360 / (Sensitivity * Yaw * MouseDPI/2.54) = 360 / (5 * 0.0066 * 800/2.54) = 34.63636363636364 RealSensitivity (visuomotor ratio) = ProjectionCircumference / SensitivityCircumference = 135.5376348526406 / 34.63636363636364 = 3.9131600613623263 Or SensitivityCircumference (cm) = ProjectionCircumference / RealSensitivity = 135.5376348526406 / 3.9131600613623263 = 34.63636363636364

The best thing about focal length is that you can use it to calculate your true, universal sensitivity value, taking all variables into account. Maybe it will become the standard measurement to share how fast your sensitivity is with someone in the future, who knows. At the moment people share cm/360 values, but that is only slightly better than sharing eDPI values. It still doesn't tell anyone how sensitive the mouse is as you don't know their monitor size, fov, and how much of the monitor that fov is occupying. All it really tells you is how tedious it is to turn corners and change directions. Basically the focal length is the radius of the projection, and the length of the radius will vary depending on the fov and how large a pixel is (resolution and monitor size). You use the radius to calculate the circumference. The size of the circumference becomes your cm/360 (which is also a circumference). You then divide that cm/360 by a number. That number is your universal sensitivity value, which I call visuomotor since it's a ratio between visual and motor. If you have a sensitivity of 4, then your projection's circumference is always 4x larger than your sensitivity's circumference (cm/360). It is similar to getting your real 2D sensitivity, which is how fast/far the cursor travels relative to your mouse. If you have a sensitivity of 4, then your cursor moves 4x faster/further than your mouse. If you convert 0% mm from windows to a game, then your universal sensitivity value becomes the same as your real 2D sensitivity. Your camera moves at the same speed as the cursor. The distances to reach things on the screen is all different though but that doesn't matter, that's the pitfall of monitor distance. But yeah, if you are just scaling sensitivity between fovs, without changing anything else, then you can safely use 0% mm. It will calculate the change thats happening to the focal length / radius, and change your cm/360 by the same factor. Both of those spheres in the picture will scale by the same rate, and 0% will keep that ratio the same.

Assuming every variable is constant except for the fov, then yes it gives the same result. If you are converting between different sized monitors, or non upscaled resolutions, then you want to use the actual focal lengths instead because mm 0% will give incorrect results. E.g. You have a case where you are converting from a 960x540 windowed game with 53.13 fov, to a fullscreen 1920x1080 game with 90 fov. mm 0% would just see that 90 fov is zoomed out twice as much as 53.13 and then double your sensitivity, even though both games have identical focal lengths. Both have 53.13 fov within the 960x540 region of the screen.

You only need to change to 116 fov, everything else can be the same. It will be the same as using your 24", except the extra 3" is providing extra fov.

For 2D sensitivity, your cursor moves slower on the 27", at 0.8x the speed. For 3D sensitivity, your sensitivity will feel faster on the 27", 1.125x the speed. This is because you have the same field of view on the new screen, even though it is a larger size. You need to have a higher fov on the larger screen, maintaining the original 110 fov within the 24" portion of your new 27" screen. Using 110 on the new 27" is the same as using ~103.5 on the old 24". If you want to have identical sensitivity, you need to increase the field of view on the 27" to ~116.2. If you don't adjust the fov, you would have to reduce your sensitivity by 0.888x instead (cm/360 will increase by 1.125x), which will be identical to converting from 110 fov to 103.5 fov using monitor distance 0%. tldr: You need to use 110 fov on the 24" and 116.2 fov on the 27".

Convert to scopes using a monitor distance instead of 360 distance. It makes no sense to convert 360 distance when aiming as it's only useful for consistent mouse swipes for turning corners and looking behind, which are low precision movements by nature and only useful for hipfire where you will be primarily navigating a map. Monitor distance basically compares the difference in hipfire and scope fov and applies that change to the sensitivity. Due to the 3D -> 2D projection, the fov difference changes based on where you take the measurement. At 0% the change is equal to the magnification, at 100% it will be the change in vertical or horizontal fov seen on the screen, at infinite % all fovs are equal to 180 degrees so there is zero change and you just end up with 360 distance. Lower % has more change, higher % has less change, find a % that doesn't feel too slow or too fast for all fovs.

I dont think the ads fov is simple subtraction. You can set the fov to 30 and scopes will still work fine without going into the negatives.

(1/x)^zoomsensitivity seems to be the multiplier applied. x being 1.1, 1.2, or 1.5 depending on weapon. 0 = 1x. 2 = 1.21x, 1.44x, or 2.25x slower. For zoom fovs, it seems to subtract but it varies per weapon and not per weapon class. The unity pistol has a different zoom than the lexington for example. Quite disappointing overall.

Maybe this will help with understanding, it is something i posted on reddit but it covers the same topic