Vols and Jezuz

Yeah it makes sense to wait.
Here is my method for converting CS:GO sensitivity to PUBG, and it should work for other Source games. Where it gets interesting is that I preserve the behavior of the scoped mouse sensitivity from CS:GO and its zoom_sensitivity_ratio_mouse. While Valve's method for handling scoped sensitivity is far from perfect, as has been discussed ad nauseam on this forum and other places, it is the behavior that feels most natural to me now after years of playing CS:GO and TF2. After refining this method and trying it out extensively in-game, I'm extremely satisfied with how familiar and seamless the aim feels across all scopes/FOVs. All the other methods I've tried that use Viewspeed or various Monitor Distances just did not feel right across all scopes/FOVs.
Note, this method was made for people who primarily stay in third person except to engage in gunfights. This will need a little tweaking once first person only servers come out. Also note that I've included corrected magnifications for the 8x and 15x scopes, as discussed a few posts above. Edit: these steps are now obsolete, check this post for updated instructions.
 
1) Convert your CS:GO 360° rotation to PUBG Hipfire using the calculator. For me, 1 sensitivity @ 900DPI = 46.1818cm per 360°, which gives 0.009900 for PUBG Hipfire. The reason that I've used PUBG's third person (Hipfire) for 360° rotation conversion is because it is the mode you will almost always be in when you need to do large flicks. If you hear gunfire coming from 100m directly behind you, for instance, almost everyone will turn the 180° in third person, because the camera angle and increased FOV help you locate where the gunfire is coming from. Then once you have located the enemy, you switch to ADS or scope in to engage them, for the increased clarity from the zoomed in FOV and lower spread/deviation. So the muscle memory you have built in CS:GO for snapping to precise angles aligns best with PUBG's third person (Hipfire).
2) Hipfire is named Normal in the config file. For VehicleDriver and Targeting in the config file, use the same sensitivity that you calculated in step 1 for Hipfire, since they are all the same FOV.
3) Go to this Google spreadsheet and then "File" > "Download as" so you can have a copy to edit. In the green boxes, edit the red text to enter your personal CS:GO cm per 360° from the calculator and zoom_sensitivity_ratio_mouse (my values are just there as an example).
4) To make zoomed FOV sensitivity behave like CS:GO and other Source games with zoom sensitivity ratio, the target 360° rotation for PUBG Scoping is calculated in cm by starting with the Hipfire 360° rotation and multiplying it by the FOV magnification, then dividing by the zoom sensitivity ratio. This way, the change in a zoomed FOV's sensitivity changes according to the FOV in the exact same way as with the various zoom levels in CS:GO. Sniper rifles' first zoom, AWP second zoom, SSG 08/G3SG1/SCAR-20 second zoom, and AUG/SG 55 zoom are all different magnifications and FOVs in CS:GO, but are all controlled by the same zoom_sensitivity_ratio_mouse value.
5) EDIT - For these last 2 steps, only pick PUBG as the first game in the calculator, don't pick CS:GO for the first game and PUBG as the second game to convert. To get your PUBG Scoping sensitivity, pick Scoping under Aim in the calculator, enter your DPI, and manually alter the sensitivity value until the green 360° rotation value in the CALCULATIONS box is as close to the spreadsheet's Scoping target 360° rotation as possible. Keep in mind that the game only uses six decimal places (0.xxxxxx) for config values, so don't waste your time getting more exact than that. This might sound like it would take forever, but it goes quickly once you get a method down.
6) Scope 2X/4X/8X/15X  target 360° rotations are all calculated similarly to Scoping in step 4, but they are calculated relative to Scoping 360° rotation. So just repeat step 5 for the remaining sensitivities, matching the calculator's green 360° rotation values to the spreadsheet's target 360° rotation values. Make sure to change the calculator's Aim selection for each Scope level, as the same sensitivity value gives different 360° rotations for each of the Aim choices.
 
When you are all done, you should end up with a list of values similar to mine below. You will need to look up how to edit PUBG's config file if you are not familiar with it, and you will probably have to make it Read-only or the game will probably revert your values at some point in time. I suggest making a backup of the config file in case this ever happens.
Normal: 0.009900 VehicleDriver: 0.009900 Targeting: 0.009900 Scoping: 0.008749 Scope2X: 0.007732 Scope4X: 0.007732 Scope8X: 0.008532 Scope15X: 0.009665

I realized that my spreadsheets had an error where I was calculating target distances with the zoom sensitivity ratio relative to the 16:9 magnification instead of relative to the 4:3 magnification like CS:GO does. All three spreadsheets have been updated.
One consequence of this correction is that the Scoping and Scope 2x/4x/8x/15x sensitivities will now all be different values, even if you are using zoom_sensitivity_ratio_mouse 1, since PUBG's sensitivity scaling is relative to 16:9 instead of 4:3 like CS:GO.

Okay, so the magnification calculations in my spreadsheet are correct then, because the third person Scoping and Scope 2x/4x/8x/15x are relative to FOV 80 and the first person ones are relative to the chosen FpsCamearFov. Thanks

UPDATE: Added everything for both in-game and config file now. Adjusted formulas to be 100% accurate (some very small rounding errors may have happened earlier).

Yeah it makes sense to wait.
Here is my method for converting CS:GO sensitivity to PUBG, and it should work for other Source games. Where it gets interesting is that I preserve the behavior of the scoped mouse sensitivity from CS:GO and its zoom_sensitivity_ratio_mouse. While Valve's method for handling scoped sensitivity is far from perfect, as has been discussed ad nauseam on this forum and other places, it is the behavior that feels most natural to me now after years of playing CS:GO and TF2. After refining this method and trying it out extensively in-game, I'm extremely satisfied with how familiar and seamless the aim feels across all scopes/FOVs. All the other methods I've tried that use Viewspeed or various Monitor Distances just did not feel right across all scopes/FOVs.
Note, this method was made for people who primarily stay in third person except to engage in gunfights. This will need a little tweaking once first person only servers come out. Also note that I've included corrected magnifications for the 8x and 15x scopes, as discussed a few posts above. Edit: these steps are now obsolete, check this post for updated instructions.
 
1) Convert your CS:GO 360° rotation to PUBG Hipfire using the calculator. For me, 1 sensitivity @ 900DPI = 46.1818cm per 360°, which gives 0.009900 for PUBG Hipfire. The reason that I've used PUBG's third person (Hipfire) for 360° rotation conversion is because it is the mode you will almost always be in when you need to do large flicks. If you hear gunfire coming from 100m directly behind you, for instance, almost everyone will turn the 180° in third person, because the camera angle and increased FOV help you locate where the gunfire is coming from. Then once you have located the enemy, you switch to ADS or scope in to engage them, for the increased clarity from the zoomed in FOV and lower spread/deviation. So the muscle memory you have built in CS:GO for snapping to precise angles aligns best with PUBG's third person (Hipfire).
2) Hipfire is named Normal in the config file. For VehicleDriver and Targeting in the config file, use the same sensitivity that you calculated in step 1 for Hipfire, since they are all the same FOV.
3) Go to this Google spreadsheet and then "File" > "Download as" so you can have a copy to edit. In the green boxes, edit the red text to enter your personal CS:GO cm per 360° from the calculator and zoom_sensitivity_ratio_mouse (my values are just there as an example).
4) To make zoomed FOV sensitivity behave like CS:GO and other Source games with zoom sensitivity ratio, the target 360° rotation for PUBG Scoping is calculated in cm by starting with the Hipfire 360° rotation and multiplying it by the FOV magnification, then dividing by the zoom sensitivity ratio. This way, the change in a zoomed FOV's sensitivity changes according to the FOV in the exact same way as with the various zoom levels in CS:GO. Sniper rifles' first zoom, AWP second zoom, SSG 08/G3SG1/SCAR-20 second zoom, and AUG/SG 55 zoom are all different magnifications and FOVs in CS:GO, but are all controlled by the same zoom_sensitivity_ratio_mouse value.
5) EDIT - For these last 2 steps, only pick PUBG as the first game in the calculator, don't pick CS:GO for the first game and PUBG as the second game to convert. To get your PUBG Scoping sensitivity, pick Scoping under Aim in the calculator, enter your DPI, and manually alter the sensitivity value until the green 360° rotation value in the CALCULATIONS box is as close to the spreadsheet's Scoping target 360° rotation as possible. Keep in mind that the game only uses six decimal places (0.xxxxxx) for config values, so don't waste your time getting more exact than that. This might sound like it would take forever, but it goes quickly once you get a method down.
6) Scope 2X/4X/8X/15X  target 360° rotations are all calculated similarly to Scoping in step 4, but they are calculated relative to Scoping 360° rotation. So just repeat step 5 for the remaining sensitivities, matching the calculator's green 360° rotation values to the spreadsheet's target 360° rotation values. Make sure to change the calculator's Aim selection for each Scope level, as the same sensitivity value gives different 360° rotations for each of the Aim choices.
 
When you are all done, you should end up with a list of values similar to mine below. You will need to look up how to edit PUBG's config file if you are not familiar with it, and you will probably have to make it Read-only or the game will probably revert your values at some point in time. I suggest making a backup of the config file in case this ever happens.
Normal: 0.009900 VehicleDriver: 0.009900 Targeting: 0.009900 Scoping: 0.008749 Scope2X: 0.007732 Scope4X: 0.007732 Scope8X: 0.008532 Scope15X: 0.009665

Yeah it makes sense to wait.
Here is my method for converting CS:GO sensitivity to PUBG, and it should work for other Source games. Where it gets interesting is that I preserve the behavior of the scoped mouse sensitivity from CS:GO and its zoom_sensitivity_ratio_mouse. While Valve's method for handling scoped sensitivity is far from perfect, as has been discussed ad nauseam on this forum and other places, it is the behavior that feels most natural to me now after years of playing CS:GO and TF2. After refining this method and trying it out extensively in-game, I'm extremely satisfied with how familiar and seamless the aim feels across all scopes/FOVs. All the other methods I've tried that use Viewspeed or various Monitor Distances just did not feel right across all scopes/FOVs.
Note, this method was made for people who primarily stay in third person except to engage in gunfights. This will need a little tweaking once first person only servers come out. Also note that I've included corrected magnifications for the 8x and 15x scopes, as discussed a few posts above. Edit: these steps are now obsolete, check this post for updated instructions.
 
1) Convert your CS:GO 360° rotation to PUBG Hipfire using the calculator. For me, 1 sensitivity @ 900DPI = 46.1818cm per 360°, which gives 0.009900 for PUBG Hipfire. The reason that I've used PUBG's third person (Hipfire) for 360° rotation conversion is because it is the mode you will almost always be in when you need to do large flicks. If you hear gunfire coming from 100m directly behind you, for instance, almost everyone will turn the 180° in third person, because the camera angle and increased FOV help you locate where the gunfire is coming from. Then once you have located the enemy, you switch to ADS or scope in to engage them, for the increased clarity from the zoomed in FOV and lower spread/deviation. So the muscle memory you have built in CS:GO for snapping to precise angles aligns best with PUBG's third person (Hipfire).
2) Hipfire is named Normal in the config file. For VehicleDriver and Targeting in the config file, use the same sensitivity that you calculated in step 1 for Hipfire, since they are all the same FOV.
3) Go to this Google spreadsheet and then "File" > "Download as" so you can have a copy to edit. In the green boxes, edit the red text to enter your personal CS:GO cm per 360° from the calculator and zoom_sensitivity_ratio_mouse (my values are just there as an example).
4) To make zoomed FOV sensitivity behave like CS:GO and other Source games with zoom sensitivity ratio, the target 360° rotation for PUBG Scoping is calculated in cm by starting with the Hipfire 360° rotation and multiplying it by the FOV magnification, then dividing by the zoom sensitivity ratio. This way, the change in a zoomed FOV's sensitivity changes according to the FOV in the exact same way as with the various zoom levels in CS:GO. Sniper rifles' first zoom, AWP second zoom, SSG 08/G3SG1/SCAR-20 second zoom, and AUG/SG 55 zoom are all different magnifications and FOVs in CS:GO, but are all controlled by the same zoom_sensitivity_ratio_mouse value.
5) EDIT - For these last 2 steps, only pick PUBG as the first game in the calculator, don't pick CS:GO for the first game and PUBG as the second game to convert. To get your PUBG Scoping sensitivity, pick Scoping under Aim in the calculator, enter your DPI, and manually alter the sensitivity value until the green 360° rotation value in the CALCULATIONS box is as close to the spreadsheet's Scoping target 360° rotation as possible. Keep in mind that the game only uses six decimal places (0.xxxxxx) for config values, so don't waste your time getting more exact than that. This might sound like it would take forever, but it goes quickly once you get a method down.
6) Scope 2X/4X/8X/15X  target 360° rotations are all calculated similarly to Scoping in step 4, but they are calculated relative to Scoping 360° rotation. So just repeat step 5 for the remaining sensitivities, matching the calculator's green 360° rotation values to the spreadsheet's target 360° rotation values. Make sure to change the calculator's Aim selection for each Scope level, as the same sensitivity value gives different 360° rotations for each of the Aim choices.
 
When you are all done, you should end up with a list of values similar to mine below. You will need to look up how to edit PUBG's config file if you are not familiar with it, and you will probably have to make it Read-only or the game will probably revert your values at some point in time. I suggest making a backup of the config file in case this ever happens.
Normal: 0.009900 VehicleDriver: 0.009900 Targeting: 0.009900 Scoping: 0.008749 Scope2X: 0.007732 Scope4X: 0.007732 Scope8X: 0.008532 Scope15X: 0.009665

Your sensitivities should all be the same since your zoom sensitivity ratio is 1, like this:
Normal: 0.010890 VehicleDriver: 0.010890 Targeting: 0.010890 Scoping: 0.010890 Scope2X: 0.010890 Scope4X: 0.010890 Scope8X: 0.010890 Scope15X: 0.010890 I agree that the zoomed sensitivities feel really high when scaling with zoom sensitivity ratio 1. I would suggest that you experiment with lowering it in CS:GO, which would also make the PUBG scopes less sensitive, relatively, using my method. Maybe start with 0.978753, which is the ratio you get if you convert CS:GO Hipfire to AWP zoom level 1 using viewspeed conversion. I think around 0.9 is a really good compromise that still allows you to make all the reasonable flicks you need to make, but still not so fast that it feels out of control.

Thanks for dealing with my derpiness

I was mistaken in my correction to the 8x/15x scope sensitivities before @DPI Wizard updated the calculator to have correct magnification values. So using my method, people should always have the same sensitivities for Scoped 2x/4x/8x/15x, regardless of their zoom sensitivity ratio. If you use zoom sensitivity ratio 1 in CS:GO, then it actually works out to where ALL of the sensitivities are in fact the same. This is because PUBG's sensitivities are scaled the same as CS:GO with zoom_sensitivity_ratio_mouse 1. If you are using any other value for zoom sensitivity ratio, then you will have a different value for Scoping, and then another different value that works for all of the Scoped 2x/4x/8x/15x sensitivities.
As an example, my (finally) correct personal sensitives now are:
Normal: 0.009900 VehicleDriver: 0.009900 Targeting: 0.009900 Scoping: 0.008749 Scope2X: 0.007731 Scope4X: 0.007731 Scope8X: 0.007731 Scope15X: 0.007731 So to be clear, all your sensitivities turn out to be the same in PUBG now that the calculator is corrected because you are using zoom sensitivity ratio 1 in CS:GO. In your case, that's 0.010890 across the board.
I will get around to amending the original post I made on my method to make it shorter and better organized, and also note the corrections that have been realized since then.

I used my strategy in the previous post and was able to snag an 8x scope to take some screenshots and mouse data. I derped a little bit and did it versus third person instead of first person, but I suppose it's still fine. Here are the images for comparison if anyone wants to do any calculations with them. I tried but got too confused by the trigonometry to get much out of them.
Third person
8x scoped in
8x scoped in overlayed on third person
I also took MouseTester data to get the total x-counts in a 360° rotation. Here are the images of the points I used to start/stop on while collecting MouseTester data: third person, 8x scoped in.
For third person, it was a total of 16362 x-counts, which converts to 46.177cm per 360° with my 900DPI. This is very close to the 46.1818cm per 360° from the calculator for my 0.009900 hipfire sensitivity.
For 8x scoped in, it was a total of 173621 x-counts, which converts to 489.997cm per 360° with my 900DPI. This is not close to the 540.6461cm per 360° from the calculator for my 0.007732 Scope 8X sensitivity. However, if the calculator treated the Scope 8X sensitivity as having 7.25x magnification, then the calculator would give 489.9608cm per 360°, which is very close to my measured 489.997cm per 360°. So I think we can conclusively state that the 8x scope is indeed 7.25x magnification as reported on PUBG.ME, and we can furthermore anticipate that the 15x scope will be 12x magnification.
To demonstrate the difference this makes, the 0.007732 sensitivity I was using for Scope 8x sensitivity should actually be 0.008532 (= 0.007732 * 8 / 7.25) to take the 7.25x magnification into consideration. I was also using 0.007732 for Scope 15X sensitivity, which should actually be 0.009665 (= 0.007732 * 15 / 12) to take the 12x magnification into consideration. The various sensitivities I used for PUBG come from my own method, which I will make a post for soon, but the bottom line is that this effects everyone who used the calculator for deriving Scope 8X and Scope 15X sensitivities.
Oh, and somehow I managed to win that game after I collected these screenshots and mouse data even though I was just trying to find an 8x or 15x scope for this test. Just goes to show, man's best laid plans in PUBG

RInput involves extra calls to the Win32 API functions GetCursorPos and SetCursorPos to feed the game the raw input data that m_rawinput 1 does not. The 'old' v1.31 RInput suffered packet loss because it would call GetCursorPos and read the raw mouse data, but it would wait until SetCursorPos was called to reset the raw x and y accumulators. Meaning any raw data collected during polls in between these two calls was ignored. The way the Source engine is coded with m_rawinput 0 to translate cursor position changes to in-game aim, the two cursor function would ideally occur sequentially without interruption. The phenomenon of dropped mouse data packets was roughly proportional to fps_max, because the more frames that were rendered, the more work the CPU was having to do and thus the higher occurrence of something requiring CPU wall time in between Get/SetCursorPos.
 
The new RInput fixed the packet drops by instead resetting the raw x and y accumulators during the GetCursorPos call (along with another more subtle and difficult to explain change in how it accumulates the raw input data). Still, RInput requires the two extra Win32 API calls that are vulnerable to high CPU utilization and being delayed momentarily by higher-prioritized processes. Now I really am not knowledgeable enough about Windows API, Source engine frame rendering, how the streaming program(s) work, or CPU prioritization to know exactly could be going on if what you're saying is true, but I imagine it's one of these possibilities:
 
1) streaming is causing frequent ~100% utilization of the CPU core that is also handling Get/SetCursorPos, so those functions are subject to having to wait for CPU wall time, which could either delay the frame rendering they're being called for, or cause that cursor change to be delayed to the next frame (thus inducing 1 frame of input lag)
2) your streaming implementation isn't causing ~100% core utilization happens to be particularly taxing on the Windows API, causing some kind of collision with the Get/SetCursorPos timing
3) the streaming processes have higher priority than the game process, so calls such as Get/SetCursorPos are ceding time to the streaming processes during high CPU utilization (this possibility could be easily fixed by setting the streaming processes lower priority than the game with Prio)
 
Whatever the case, you could invest ~$20 in a Teensy and easily program it to perform exact patterns of mouse input to demonstrate with empirical evidence what you say you are experiencing.