The use cases in question (intersection welding in a build game, checking if functional parts such as reactors, lasers, engines were clipped into each other) already tolerated minor errors, but the new (unannounced) behavior changes required some pretty invasive changes to those systems to make them work like they did before.
For example, the building games I work on support part surfaces. We use a combination of :MakeJoints() and :GetPartsInPart()-based intersection welding to allow for surface welding, surface joints (hinges), and complex shapes all in one system. With the new behavior of :GetPartsInPart(), parts that are touching are now detected as intersecting. For now we’ve reverted to :GetTouchingParts(), but this is much slower, less reliable, and does not use OverlapParams, making it more annoying to restrict what it returns.
I’m happy the method is now much more performant, but I’m not particularly excited about the unannounced changes to its behavior. Would it be possible to still have the old functionality under a flag, similar to OverlapParams.BruteForceAllSlow?
Alternatively, the slop factor you mentioned - WorldRoot:ArePartsTouchingOthers() supports a threshold before parts are considered touching. If it’s possible to have this functionality in OverlapParams or wherever it makes the most sense, it would be a good replacement for the old functionality, as developers could tune this threshold to best fit their use cases.
Is there some other change you’re trying to get at here? Because like I said before, there is no hard dividing line between “touching” and “intersecting”, at the end of the day it’s all just fuzzy thresholds.
I understand that the line between touching and intersecting doesn’t really exist. The change I’m talking about is the behavior of :GetTouchingParts(), which I showed in a screenshot above. Before 576 it did not return parts that were touching the surface (or at least, not very often), and definitely did not return parts that weren’t touching at all but were still less than 0.01 studs away from the surface. This was not an issue until 576 released. I posted a chart above showing the expected (pre 576) behavior with all of the cases shown. The expected chart lines up with what was observed in the mentioned building game until 576 released.
The new behavior for :GetPartsInPart() is not only too sensitive around normal part shapes, but seemingly ignores the outer parts of meshes. My first thought was this could be a mesh issue with our game (our meshes are pretty janky) but I tested it with various trapezoid meshes I found around the marketplace and they all had the same issue.
I’ve attached both the mesh issue and original chart repro place. Is there any chance we could get a response on this? I understand that there’s no easily drawn line between touching and intersecting in cases like these, but the previous version of this method seemed to handle those cases reliably enough. All of these test cases worked fine (with the occasional issue, but nothing like this) since the Spatial Query API released 2 years ago, with no noticeable change in behavior until 576.
I listed some potential solutions above: a flag (similar to OverlapParams.BruteForceAllSlow) would let us use the old behavior in cases where it works better (most of them) or alternatively exposing the mentioned slop factor in more methods, or as a property of OverlapParams. A solution would be nice, the alternative is to go back to :GetTouchingParts(), which also handles the above cases just fine, but doesn’t have OverlapParams and is generally much slower and less consistent.
After discussing internally, our team has decided to revert the deprecation of shiftlock related properties, including EnableMouseLockOption. We will be working on a better approach to provide support for these features in the future.
However, we would like to encourage you to utilize MouseBehavior if you only require mouse lock functionality.
The reversion is expected to take place within the next 1-2 releases.
We apologize for any confusion caused during this period and appreciate your patience.
What I originally meant is, MouseLock and MouseBehavior are entirely different.
You can test this by working with MouseBehaviour, if you set it to locked it doesn’t change the image. This doesn’t mean it’s terrible or anything, I support this as MouseLock has always been weird (considering DevEnableMouseLock was only server-sided, even though it could still be exploitable, and there was no good way around to setting MouseLock state without modifying the PlayerModule).
Ever since MouseBehavior has been added, everything has been made better. My point was that MouseBehavior and MouseLock have nothing to do, and you can see this by checking the camera modules, you’ll notice it (both behave exactly the same but MouseBehavior is far superior because it can be customized, unlike the preset MouseLock image, for example).
you can see both do not have anything to do between them in these pictures, because even with shiftlock off its still locked, which is good, because developers should disable DevEnableMouseLock and add their own functionality
FYI–I’ve seen some people nervous about the deprecation of the CollectionService methods here and interpreting it as a deprecation of tags as a system entirely. This is definitely not the case! The new methods are just more convenient ways of accessing their respective methods (Instance:GetTags() is CollectionService:GetTags(instance)).
Ok that makes sense, but would this break games if CollectionService is inherited from Instance? I like the new methods, but it looks like the new Instance methods would just override CollectionService methods.