AuRea provides an application-level layer for building AR scenes composed of a world, tracking-driven anchors, 3D content, and 2D panels turned into renderable objects. The overall model is straightforward: the app receives the AR session state, AuRea maintains a scene representation, and the native engine handles rendering.
AuRea includes the GiPStech ARDK as an API dependency. As a result, when integrating AuRea, the application does not need to add ARDK again on its own.
For ARDK initialization and for obtaining and configuring the ARDK development key, the correct reference is the ARDK manual. Those steps are part of the ARDK setup and should follow the procedures described in its own documentation.
Important note
Section titled “Important note”Please carefully read License Agreement terms and conditions before continuing. Downloading or consulting any material within this developer site will constitute acceptance of those terms and conditions.
High-level architecture
Section titled “High-level architecture”The main framework concepts are:
- AuWorld: the root of the scene and the integration point with the AR session.
- AuAnchor: a node attached to a Marker, used to make content follow a tracked target.
- AuEntity: the base type for renderable or transformable scene elements.
- AuContainer: the common contract for nodes that can contain other entities, such as AuWorld, AuAnchor, and AuGroup.
- AuWidget: a hierarchy for building 2D content that is later converted into textured 3D objects.
In a typical usage flow:
- create an AuWorld bound to the ARSession;
- add anchors and content to the scene;
- load external resources when needed;
- forward rendering loop events to the world;
- explicitly release native resources when they are no longer needed.
Native resources and unmanaged heap
Section titled “Native resources and unmanaged heap”Every main AuRea object has a native counterpart allocated outside the Kotlin-managed heap. In practice, when you create an AuWorld, an AuAnchor, an AuMesh, an AuTexture, an animation, or a 3D object, a corresponding native object is also created in the unmanaged heap.
All of these types derive from AuNative. This has two important consequences:
- they expose a handle to a native resource;
- they manage access to that resource through a shared pointer abstraction rather than directly controlling the underlying unmanaged memory.
Calling close() does not guarantee immediate deallocation of the unmanaged memory. Instead, it releases the Kotlin-side reference to the native resource. The actual deallocation happens only when all native/shared references to that resource are released.
Garbage collection alone is not enough to guarantee timely release of native resources. For this reason, close() should be called when the managed object is no longer needed to access the methods and properties of the unmanaged object. Therefore, the recommended approach is to use the use { ... } block to ensure proper and timely release of the resource.
How to handle deallocation
Section titled “How to handle deallocation”The practical guidelines are:
- close AuWorld when the scene is being disposed;
- close anchors, meshes, textures, animations, and dynamically created objects when they are permanently removed;
- prefer
use { ... }blocks for temporary resources; - avoid using an object after
close(), because its handle is no longer valid.
A sound strategy is to align the lifetime of each resource with that of its logical container: