VberAI export into game engines: one artboard in Godot and Unity

TL;DR

The same artboard was exported twice from VberAI Studio: once to Unity, stored in Unity’s project folder layout, and once to Godot, stored in Godot’s layout. This is a full comparison of those two exports. The recording is on YouTube. What matches: 29 PNGs, same bytes and same filenames, one 1920×1080 screen, the same node names, and positions already written into the scene file. What differs: Godot unzips as one flat list, 59 files. Unity unzips as Assets, then Textures, Prefabs, and Materials, 66 files. Godot writes the four text labels on the node. Unity writes that text style as three material files.

The export does the job. Both folders are art laid out the way that engine expects. Open the project, and MCP can read the screen already placed.

Two different folders, both ready for MCP to place the screen

Open the two zips side by side. The Godot zip is one list of files. The Unity zip opens on Assets, and inside that are three folders. The layouts differ. Both are art folders shaped for that engine: names and positions are already in the files. Put the export into the project, keep the editor open, and MCP reads this 1920×1080 screen already assembled.

Figma to Godot and Figma to Unity describe the folders each engine expects. The clicks below are this one board in both zips. Both exports are here to download:

Godot zip: 59 files, one flat list after unzip.
Unity zip: 66 files. The first folder is Assets.

What matches, unpacked: 29 images

Open any PNG that shares a name. The bytes match. The filenames match.

The board and the pieces on it:

background_2_2.png
pirate_ship.png, lava_platform.png
wooden_tower.png, wooden_hut.png, red_crystal_tower.png, pirate_skull_tower.png, fire_tower.png, dark_skull_tower.png

Cards and spells:

large_skull_tower_card.png, skull_tower_card_one.png, skull_tower_card_two.png, skull_tower_card_three.png, skull_tower_card_four.png
green_spell_card.png, fire_spell_card.png, blue_spell_card.png

Interface:

resource_status_bar.png, health_bar_2.png
gold_button_one.png, gold_button_two.png, gold_button_three.png
pause_button.png, pause_small_icon.png
coin_icon_2_2.png, skull_icon.png, heart_icon_2.png, shield_icon_2.png, metal_orb_icon.png

Four names are labeled in the scene, and they have no cut image. skull_count, coin_amount_2, life_count, and tower_level do not appear as PNG files. The words on screen — 6/15, 340, 6, and 10 — are typed on the node.

Name in the scene	Words on screen	Font size
`skull_count`	6/15	19
`coin_amount_2`	340	19
`life_count`	6	17
`tower_level`	10	21

Godot: 59 files in one list

Open the Godot zip. This is the whole package:

*.png                     29 images
*.png.import              29 import files, one beside each image
*.1920x1080_layer.tscn    1 scene

.tscn is short for text scene. The scene root is a Control at 1920×1080. Under it: 29 TextureRect nodes and 4 Label nodes. Each picture points at res://<name>.png, the file sitting in this same list. Each .import tells Godot to treat that PNG as a texture. The font color, the outline, and the shadow are written on the Label.

The scene filename is the board id plus 1920x1080_layer.

Unity: 66 files under Assets

Open the Unity zip. The first thing on screen is Assets, the root folder where a Unity project keeps its files. Go in, and there are three folders:

Assets/Textures/*.png                 29 images
Assets/Textures/*.png.meta            29 import files, one beside each image
Assets/Prefabs/*.1920x1080_layer.prefab
Assets/Prefabs/*.prefab.meta
Assets/Materials/TMP_FX_*.mat         3 text-style files
Assets/Materials/*.mat.meta

The Prefab root is a Canvas at a reference size of 1920×1080. The child names match the Godot nodes. Each .meta imports the PNG as a Sprite.

Unity unzips as three folders inside Assets

Unity imports files that live under the project’s Assets directory. This zip therefore starts at Assets. Once it is copied into the project, Textures, Prefabs, and Materials join the directory tree the editor is already following in real time. A PNG left at the root of the zip stays outside that tree, and the editor does not import it.

The three folders are the three kinds of file this screen uses. Click each one:

Textures is the pictures. Each PNG has a .meta beside it. A Sprite is the image Unity uses on a UI. The GUID in that .meta is the id the project uses for the image. The .meta is already written in the export. After the folder is in the project and the editor refreshes, Unity imports with those settings.
Prefabs is the assembled screen. This export has one .prefab. The .prefab.meta beside it is that prefab’s import file. The .prefab holds the Canvas, the child names, and the position of each piece on the 1920×1080 board.
Materials here is text style only. The outline and the shadow for those four labels are three TextMesh Pro material files. skull_count and coin_amount_2 share one. life_count and tower_level each have their own. Each file has OUTLINE_ON and UNDERLAY_ON.

The Godot package does not add those folders. The scene path for every image is res://<name>.png, so the .tscn and the PNGs sit in one list. The .import file does the job Unity’s .meta does, and it stays next to the PNG. The .tscn is the assembled screen, so there is no Prefabs folder. The outline stays on the Label, so there is no Materials folder. Open the Godot zip and it looks like the inside of Unity’s Textures, plus the scene file in that same list.

Which export is friendlier to MCP, Unity or Godot

They are equally friendly. MCP does not score folder depth. It reads the scene after the files are in the open project.

Godot MCP reads the open scene: the nodes in that .tscn, and the scripts. Unity MCP reads the open scene: the GameObjects, and the Prefab under Assets/Prefabs. MCP is that channel. On both sides the names and the positions are already written, so placing this screen back on the board is already done in the export.

The zip still has to be copied into the project first. A later edit on the board shows up after another export, and only then in MCP. A logic change inside Godot, or inside Unity, still needs an export from the board before that new context can drive the next generation.

Questions

What does Assets do in Unity?

Assets is the root folder for files in a Unity project. Pictures, prefabs, and materials sit under it. The editor imports files from this tree. This zip starts with Assets so that, once copied into a project, those folders join the tree the editor is already following.

Why does it look like two prefabs?

Open Prefabs and there are two files. There is one prefab.

....1920x1080_layer.prefab is the prefab. The whole 1920×1080 screen is in that one file: the positions of the 29 pictures, and the four text labels.

The .prefab.meta with the same name is the import file for that prefab. It stores the prefab’s GUID. The 29 pictures are all inside this one prefab.

Are the Materials all about text?

In this export, yes. The three files in Materials are TextMesh Pro materials. Their names start with TMP_FX_. After the on-screen text is exported to Unity, the font color, outline, and shadow live in these materials. The two labels at size 19 share one. The size 17 label and the size 21 label each have their own. Godot writes that same style on the Label, so the Godot package has no such folder.

Do the .meta files in Textures apply on their own after export?

They apply once the files are inside a Unity project. Each .meta is already written next to its PNG. Unzipping does not start Unity. After Assets is in the project and the editor refreshes and imports, Unity reads those existing .meta files and uses the Sprite settings in them. There is no need to set each image by hand. If a .meta is deleted and Unity generates a new one, the GUID changes, and the prefab’s reference to that image no longer matches.

How do a GUID and a Sprite work together?

A Sprite is the image Unity uses for UI and 2D. Each PNG’s .meta holds a GUID, the id of that file inside the project. The prefab refers to each picture by that id. Rename the file later, and as long as the .meta stays, the prefab still points at the same picture. In this export the .meta files and the prefab were written together, so the ids already match.

What does Godot’s .tscn stand for?

.tscn is short for text scene. Godot stores a scene in this text file: which nodes exist, where they sit, which image each one uses, and what the text says. The binary scene file is .scn. This export is a .tscn. Open it and the 1920×1080 Control is there, with 29 TextureRect nodes and 4 Label nodes.

Takeaway

The export meets the comparison. The 1920×1080 board is in both engines, with the same pictures, the same names, and the positions already set. With the project open, MCP reads that same screen on either side.

Two gaps remain in the files themselves. The scene and the Prefab are still named with the board id plus 1920x1080_layer, so a gameplay scene name is not part of this export yet. Unity carries seven more files because the text style sits in Materials on its own. A later theme or event set of cuts can keep these image filenames and export again with Restyle.