Developers need the ability to see the Position/Properties of CoreGui

Feature Requests Engine Features
, , , ,
#1

Currently, as a developer, it is very hard - perhaps even impossible - to accurately know where certain CoreGui elements are.

I understand from a security standpoint why we cannot modify coreGui easily, but to not be allowed to see it? or know where it is? seems extremely broken from a developer’s standpoint.

As a developer, I need to be able to locate these gui items so that my own Gui does not overlap it in any way. Roblox’s Gui is useful, and many developers choose to keep it enabled, so it’s not as simple as just “Make your own” - We often want to have Roblox core Gui enabled, but if we cannot tell what it’s size and position is, we simply cannot work around it.

Here is a very simple example:
I was adding a very simple form of resource collection to my game. I wanted it to display the resources above the Backpack Hotbar - This makes 100% sense considering that I was using a tool in the backpack to collect these resources, so I thought displaying them above the backpack made perfect sense.

In this example, I cannot do that. Different resolutions change the size and position of the backpack greatly. Mobile users, specifically, have their backpack much larger proportionally than desktop users. If I have my Gui above the Backpack in desktop, the Gui would be overlapping on Mobile, and such - No amount of padding or offsets fixes this, as the size of the Backpack is coded, changing fairly dynamically.

Why? This does not make any sense. I should be able to at least access the position of various CoreGui elements so that I can as a developer accurately work around them, without being expected to just disable everything and make them from scratch. The Backpack is a well known, respected part of roblox’s engine, after all - Many players expect it to be enabled, yet, Roblox basically treats it as something that I should be disabling and making custom 100% of the time, as it is not something that can be adapted for within my own Gui.

Overall Roblox’s coreGui limitations are terrible. I understand why it is like it is, to some extent, but a significant amount of the limitations don’t make any sense. If a developer wants to see coreGui in-game, viewing it’s position and size - they should be able to, even if they shouldn’t be editing those values.

If there is a way to do this, I apologize - I have google-fu’d long and hard, and asked directly on multiple discords relating to roblox development, and everyone pointed me to this currently being impossible, despite in my opinion, it being a very important and practical function - necessary even.

15 Likes
#2

Intresting thing, we actually can see it. Just not with normal scripts, You can enable hidden objects in studio settings allowing you the ability to mess with stuff (changes you make to coregui arent saved), plugins can also do stuff within coregui during studio.

Its still a very good feature request since we wouldnt have to check for voice-chat/figure out what device a user is using to place custom UI elements.

5 Likes
#3

Yeah I’ve noticed that - I think it’s a good indication that we should be able to view it with scripts in normal games. If we can see it in Studio, it’s not like it’s trying to be hidden. It’s very strange to me that something so open to view, is just… vanished away in-game. I don’t even really understand why they have it like that to begin with - I’d expect it to be either hidden everywhere, or nowhere.

2 Likes
#4

Don’t quote me on this but iirc a point that was made in the past was that menus such as the report menu could be hooked onto by a developer, leading to users being quickly shoved out of the experience when they attempt to report the experience.

1 Like
#5

If true, this seems like a somewhat overkill response to that. We’d hope players experiencing that would report the experience in this case, so I’m not sure if I believe 100% that it’s the real reason for this.

1 Like
#6

I would like it to be known that this weird lack of CoreGui viewing has actually stalled my game currently - Due to my attempt to put an indicator Ui directly above the backpack, I am now having to figure out how to code around it.

I am likely going to simply put an offset upwards to the indicator if I detect a Touchscreen, as that tends to be when the backpack is the largest… but it’s going to look not great.

#7

I don’t know if this would be practical, but if Roblox really doesn’t want developers to access CoreGui, they could consider adding methods on StarterGui to fetch or return specific CoreGui data.

For example:

-- Returns Roblox icon size
StarterGui:GetIconSize() -> UDim2

-- Returns Roblox Icon 2D screen space position
StarterGui:GetIconOffset() -> Vector2

-- Or, a new return for StarterGui:GetCore()
StarterGui:GetCore("CoreConfiguration")

Just something so that developers can properly work with any CoreGui changes

3 Likes
#8

Exactly! Frankly, I don’t care how they do it, but it is downright embarrassing that I’m having to do complex workarounds and guess work to even know where the CoreGui is - Considering there is a moderate amount of possible core Gui, it is so incredibly important to know.

#10

The primary reason they wont allow this is because CoreGui is constantly subject to change, if they remove instances or changed some paths it’d break games.

They already allow you to access the insets and such, I’m not sure what else you’d really want.

#11

I have described what I want in detail. It’s not that complicated to understand.

It should not be Literally impossible to accurately place something directly above the Backpack, a feature that has existed since some of the earliest days of Roblox.

Constantly subject to change? Maybe, just maybe, that means it’s a good thing if we can detect & compensate for core UI that has moved/been resized at some point?

I’m not really sure the concept of a Gui being removed is an issue.
Good coding practices can compensate for Gui being changed or removed, so long as Roblox is consistent and thoughtful (as well as the developer.)

Currently it does not matter how thoughtful you are. You cannot find out where basic, essentially eternal UI elements are. It is a problem.

1 Like
#12

Step 1: In Studio settings, enable the Show CoreGui in explorer setting
Step 2: Copy the Backpack UI into PlayerGui and make it invisible

Now your scripts can read the size & position of the Backpack UI.

#13

Issue with that is that the GUI moves around depending on the device type, screen size, 10ft UI

1 Like
#14

You can use AbsolutePosition and AbsoluteSize since the backpack UI most likely uses Scale for its sizing and positioning, not Offset.

#15

Assuming you somehow get this to work with different devices (which it won’t), this again relies on the fact that the CoreScripts will never change, which is simply not the case. The CoreScripts will most likely update in the future and possibly break your proportions in the process.

2 Likes
#16

to my knowledge no core UI relies on fixed positions, they use a combo of offset + scale

1 Like
#17

Both of them are often driven by code (which is a pain when you’re trying to align stuff)

1 Like
#18

I’m pretty sure the backpack uses completely arbitrarily coded size because when I checked it the values were very strange and dynamic. For instance mobile users get a completely different Ui size.

unfortunately “copy the coreGui” is purely a workaround, and as this is a feature request page, I do NOT think workarounds are the important thing to focus on here.

1 Like
#19

Unfortunately there are only 2 days until I must push this update, so I will have to use some workarounds for now.

This will very likely mean Roblox users will experience worse UI, potentially overlapping, on various devices. This is unavoidable and 100% Roblox’s fault, as of now. I hope we can solve this weird issue and get the ability to view CoreGui positions so we can know how to avoid them in the future.

#20

Maybe some sort of function that returns the sizes and positions of all the major Core UI elements in a dictionary? Which I think, with a little extra code, would allow “attaching” UI elements to specific parts of Core UIs like AnchorPoint lets you “attach” elements to specific parts of the screen.

-- assuming the button and backpack are anchored to the center-bottom
-- of the screen
RunService.RenderStepped:Connect(function()
    local CoreUIs = CoreGui:GetBoundsOfMajorElements()
    -- I feel like they would make it Scale based instead of
    -- Offset based
    ButtonAboveBackpack.Position = UDim2.fromScale(
        0,
        CoreUIs.Backpack.Size.Y + ButtonSizeScale,
    )
end)
4 Likes
#21

This is exactly the sort of solution that’d fix this problem 100%, without allowing coreGui to be accessed in any other way. I like it. There are likely many sort of implementations like this that would work, roblox just needs to understand that it needs to be done

1 Like