Godot (.zip)

Awaken imports a Godot project from a .zip export, reading its scene files as text and reconstructing the full node tree with meshes, materials, colliders, lights, and cameras. This page explains how .tscn/.tres are parsed and what comes across.

What Awaken reads

A Godot .zip is recognised by a project.godot file at its root - that marks the project directory, and every path is resolved relative to it (case-insensitively, res://-style). Awaken then picks a single scene to import: an explicit one if given, otherwise the first that looks like a main scene (matching overview / main / demo / showcase / sample), otherwise the one with the longest path. (Unlike Unity, which imports every scene the pack ships, a Godot import reconstructs just that one scene.)

Godot's .tscn scenes and .tres resources are text, so the importer parses them directly - no Godot runtime. It resolves external resources (ExtResource) and inline sub-resources (SubResource) as it walks the node list, and it recurses into instanced PackedScenes.

The node tree

Godot's importer keeps the full node hierarchy and each node's transform. Every Node3D becomes a Awaken node; its Transform3D is decomposed into position, rotation, and scale. This is the most faithfully-preserved scene tree of any importer - Unity and Unreal flatten theirs, Godot does not.

Meshes

MeshInstance3D nodes load their ArrayMesh. Each surface of the ArrayMesh is registered as its own sub-mesh, keyed by its true surface ordinal so a dropped surface doesn't shift the rest. A single-surface mesh becomes one node; a multi-surface mesh becomes a holder with one child per surface, so each surface can carry its own material. Normals are recomputed. Geometry is welded losslessly on import.

Materials

Materials come from StandardMaterial3D, whether external (a .tres) or inline (a scene SubResource):

• Base colour (albedo_color), metallic, roughness.
• Albedo texture (albedo_texture), resolved through the scene's or resource's ExtResource table.
• Transparency - alpha only blends when the material's transparency mode is actually enabled, so an incidental sub-1 alpha doesn't make a wall see-through.

Per-surface overrides are honoured (surface_material_override/<i>), including re-skins applied to PackedScene instances - that's what keeps a re-coloured roof or tree looking right per placement rather than reverting to the prefab default. ShaderMaterial can't be reproduced, so a node using one keeps its fallback (grey).

Colliders

A CollisionShape3D's inline shape is converted to an engine-agnostic collider and attached to the nearest mesh-bearing ancestor (the visual object), not the scene root - so the collider lands on the object it belongs to. Supported inline shapes:

Godot shape	Awaken collider
BoxShape3D	Box
SphereShape3D	Sphere
CapsuleShape3D	Capsule
CylinderShape3D	Cylinder
ConvexPolygonShape3D	Convex hull
ConcavePolygonShape3D	Trimesh

Only inline sub-resource shapes are decoded. External binary Shape3D .res files (Godot's separate _Collision.res concave meshes) aren't decoded yet - that collider is skipped, but the object still imports. Compound bodies (several shapes on one object) are supported. See Colliders on import.

Instanced scenes

When a node instances a PackedScene (instance=ExtResource(...)), Awaken loads that scene and grafts its root's content - mesh, material, light, camera, colliders, and children - under the placement node, which carries the world transform. A recursion guard prevents cyclic instances from looping. This is how Godot's reusable scenes come across as placed instances.

Lights and cameras

• DirectionalLight3D imports as a directional light; OmniLight3D and SpotLight3D both become point lights. The engine has a spot light and the Unity and Unreal importers use it, so a Godot spot losing its cone is a gap in this importer rather than a missing engine feature. Colour comes from light_color, intensity from light_energy.
• Camera3D imports its FOV, near, and far planes.

Particle systems

A GPUParticles3D or CPUParticles3D node becomes a Awaken particle effect asset plus a ParticleEmitter on that node. Node-level properties (amount, lifetime, one_shot, explosiveness, local_coords) are read directly; the physics - initial velocity, spread, gravity, damping, colour ramp, scale curve and emission shape - come from the node's process_material, resolved one hop through its SubResource/ExtResource reference.

Expect an approximation rather than a reproduction:

• explosiveness collapses to a binary choice - at 0.5 or above (or with one_shot set) the effect becomes a single burst of the whole pool, otherwise a continuous rate of amount / lifetime.
• Velocity min/max becomes a mean speed plus a fractional variance.
• damping (per-second linear) is converted to Awaken's exponential drag, which is only exact near the original speed.
• Curves and gradients (scale_curve, color_ramp) keep their endpoints; an inline Gradient decodes faithfully, a curve does not.
• A ParticleProcessMaterial stored as a binary .res is not decoded - the node still imports with its node-level properties and defaults. Inline .tscn sub-resources and external .tres files are fully read.

Sky and environment

A WorldEnvironment node drives Awaken's Render Settings. Its Environment resource is read for:

• Sky - a ProceduralSkyMaterial's top/horizon/ground colours become a 3-stop gradient.
• Ambient colour and energy.
• Exposure - tonemap_exposure and adjustment_brightness are folded into Awaken's EV exposure.
• Colour grade - contrast and saturation, when adjustment_enabled.
• Glow (bloom), fog, and SSAO, but only when the project actually enables each - Awaken's defaults are not imposed.

The first WorldEnvironment encountered wins.

📸 Screenshot - save as img/import-godot-result.png

A Godot demo scene freshly imported into the Awaken viewport, with the Hierarchy panel showing the preserved node tree on the left.

Known limits

• No terrain import (Godot has no built-in terrain equivalent that Awaken reads).
• Spot lights become point lights; area lights aren't imported.
• ShaderMaterial nodes keep a grey fallback - only StandardMaterial3D is reproducible.
• External binary collision .res meshes aren't decoded yet.
• No skeletal animation - skinned meshes import at their rest shape.

See also

• Importing Assets - the pipeline and support matrix
• The Import Dialog - choosing files and the texture cap
• Colliders, Skeletons, Lights & Cameras - collider detail
• Render Settings - where sky and grade land
• Prefabs - placing imported models