i need a way to seralize unions and put them into a datastore. im currently using the same method as any other instance to seralize it and that works just fine but when loading it the union becomes invisible, as shown in the picture
its supposed to look like this
is there any way to save/load unions?
i saw this. problem is i have no idea what the union is made of, and i cant separate it
I know this isn’t what you want, but… If the union was in storage all you would need is the name. Seriously would cut down on the database size also.
But if you insist; When saving a UnionOperation to a DataStore, you lose the actual geometry and rendering data because unions are not directly serializable in Roblox’s DataStore. Instead, you need to save the individual parts that make up the union and reconstruct it on load.
An untested attempt at that…
local function serializeUnion(union)
local data = {}
for _, part in ipairs(union:GetChildren()) do
table.insert(data, {
Position = part.Position,
Size = part.Size,
Orientation = part.Orientation,
Material = part.Material,
Color = part.Color,
CanCollide = part.CanCollide,
})
end
return data
end
local function loadUnion(data)
local parts = {}
for _, partData in ipairs(data) do
local part = Instance.new("Part")
part.Position = partData.Position
part.Size = partData.Size
part.Orientation = partData.Orientation
part.Material = partData.Material
part.Color = partData.Color
part.CanCollide = partData.CanCollide
part.Anchored = true
part.Parent = workspace
table.insert(parts, part)
end
local union = table.unpack(parts):UnionAsync(parts)
return union
end
Kind of defeats the purpose here but maybe you can figure something out.
This is just a guess with some wishful thinking…
the place is a map maker nothing is stored because the player creates all of it, i need to be able to save and load it back in
again same exact problem i dont know what parts the union is made of
Then you wouldn’t be able to do it, there isn’t an API to separate the union during runtime. If its for a map maker my only suggestion would be not allowing unions in the build or have collection of unions the user can use.
I wonder what would happen if each part was set up to be what it needs to be before creating the Union with them… Probably wouldn’t work due to what I said before… However, I’ve never actually tried that. Cloning the part from storage is pretty simplistic, so I’ve always gone that route.
the map maker uses a plugin to transfer builds from studio to the game, is there any way to separate unions using the plugin?
There isn’t any APIs available within GeometryService that allows separation of a union during runtime or within a plugin.
Another thing you could possibly do is alter the code of @2112Jay saving/loading of the union, basically allowing the user to a union but have them manually separate the union within studio so that you have the entire structure of how the union was made then when they import it into game or whatever it’ll restructure it.
found it, plugin:Separate() takes in a list of unions and outputs a list of parts they separated into
figured out a way to save unions, on the plugin side it will separate the unions and serialize the parts that make it up and store that in a geometry list and send it over like normal
then rebuilding it will use the BasePart:UnionAsync() to rebuild the geometry but it will also save what parts make up that union in order for it to be able to be stored in a datastore. it will save the local offsets from the main part since the main part could have been moved
ive managed to do it but its so slow. it takes 10+ minutes to export 100+ unions
and about 20+ minutes to import those
anybody know how to speed it up?
export code
local clone = Object:Clone()
local success, parts = pcall(function()
return plugin:Separate({clone})
end)
if not success then
clone:Destroy()
return nil
end
for i, v: BasePart in ipairs(parts) do
-- goes back to the start with the new parts and repeats the process if another union
table.insert(data.Geometry, self:ConvertToTable(v, nil, false, true))
v:Destroy()
task.wait()
end
import code
elseif (Data.ClassName == "UnionOperation" or Data.ClassName == "NegateOperation" or Data.ClassName == "IntersectOperation") and typeof(Data.Geometry) == "table" and #Data.Geometry > 0 then
local unions = {}
local subtractions = {}
for i, data in ipairs(Data.Geometry) do
local isNegative = data.ClassName == "NegateOperation"
local inst = self:ConvertToInstance(data, true)
if inst == nil then
continue
end
if isNegative then
table.insert(subtractions, inst)
else
table.insert(unions, inst)
end
end
if #unions == 0 then
return nil
end
if Data.ClassName == "IntersectOperation" then
for _, v in pairs(subtractions) do
table.insert(unions, v)
end
table.clear(subtractions)
for _, v in pairs(unions) do
v.Parent = workspace
end
local basePart = unions[1]
local unioned = basePart
table.remove(unions, 1)
if #unions > 0 then
local success, result = pcall(function()
return unioned:IntersectAsync(unions)
end)
if not success then
return nil
else
unioned = result
end
end
if #unions > 0 then
basePart:Destroy()
end
for _, v in pairs(unions) do
v:Destroy()
end
if unioned == nil then
success = false
else
success = true
instance = unioned
end
else
for _, v in pairs(unions) do
v.Parent = workspace
end
for _, v in pairs(subtractions) do
v.Parent = workspace
end
local basePart = unions[1]
local unioned = basePart
table.remove(unions, 1)
if #unions > 0 then
local success, result = pcall(function()
return unioned:UnionAsync(unions)
end)
if not success then
return nil
else
unioned = result
end
end
if #subtractions > 0 then
local success, result = pcall(function()
return unioned:SubtractAsync(subtractions)
end)
if not success then
return nil
else
unioned = result
end
end
if #unions > 0 or #subtractions > 0 then
basePart:Destroy()
end
for _, v in pairs(unions) do
v:Destroy()
end
for _, v in pairs(subtractions) do
v:Destroy()
end
if unioned == nil then
success = false
else
success = true
instance = unioned
end
end
What if you save the important data from all the pieces that made up that union (Size, CFrame, Color3) and then re-unite them when that data is loaded? And to make it lighter, store them in a buffer (buffers can be saved in the data store). Tell me if this idea isn’t too far-fetched, and I’ll work on it.
it already does that, its below the code i showed for the export. problem is with unions is that if you just create a blank union (which you can do with a script) it wont have any geometry which would make it invisible and have no collision (depending on the collision fidedlity)
in order for the unions to load properly you have to rebuild them like i am doing but this takes so long because plugin:Separate(), BasePart:UnionAsnyc(), BasePart:SubtractAsnyc() and BasePart:IntersectAsync() yield. that doesnt have much of an effect for small amounts but large amounts, such as 400+ unions that adds up fast and takes a very long time to load in