Add Sdf Element

SDFormat package (Parser)  →  Import.Loader (Importer)  →  Implement.* (Implementer)
        ↓                            ↓                            ↓
  C# domain class           Unity GameObjects created    Components/colliders/renderers
                                     ↓
                              Helper.* MonoBehaviour (runtime state)

// In the SDFormat package:
namespace SDFormat
{
    public class MyElement
    {
        public string Name { get; set; }
        public Math.Pose3d RawPose { get; set; }
        public string PoseRelativeTo { get; set; }
        // Add fields matching SDF XML attributes/children
    }
}

// In the parent class (e.g., Model):
public IReadOnlyList<MyElement> MyElements => _myElements;

protected virtual object ImportMyElement(in MyElement element, in object parentObject)
{
    PrintNotImported(MethodBase.GetCurrentMethod().Name, element.Name);
    return null;
}

protected virtual void AfterImportMyElement(in MyElement element, in object targetObject)
{
    PrintNotImported(MethodBase.GetCurrentMethod().Name, element.Name);
}

private void ImportMyElements(IReadOnlyList<MyElement> items, in object parentObject)
{
    foreach (var item in items)
    {
        var createdObject = ImportMyElement(item, parentObject);
        // If the element has sub-elements:
        // ImportGeometry(item.Geom, createdObject);
        // StorePlugins(item.Plugins, createdObject);
    }
}

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using UE = UnityEngine;

namespace SDFormat
{
    using Implement;
    namespace Import
    {
        public partial class Loader : Base
        {
            protected override object ImportMyElement(in MyElement element, in object parentObject)
            {
                var targetObject = parentObject as UE.GameObject;

                var newObject = targetObject.CreateMyElement(element);

                return newObject;
            }
        }
    }
}

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using UE = UnityEngine;

namespace SDFormat
{
    namespace Implement
    {
        public static class MyElement
        {
            public static UE.GameObject CreateMyElement(
                this UE.GameObject targetObject, in SDFormat.MyElement element)
            {
                var newObject = new UE.GameObject(element.Name);
                newObject.tag = "MyTag";  // Use existing tag or request a new one

                newObject.transform.SetParent(targetObject.transform, false);

                // Apply SDF pose
                if (element.RawPose != null)
                {
                    var (pos, rot) = element.RawPose.ToUnity();
                    newObject.transform.localPosition = pos;
                    newObject.transform.localRotation = rot;
                }

                // Add Helper for runtime state
                var helper = newObject.AddComponent<Helper.MyElement>();
                helper.Pose = element.RawPose;
                helper.PoseRelativeTo = element.PoseRelativeTo;

                // Create Unity components (renderers, colliders, etc.)
                // ...

                return newObject;
            }
        }
    }
}

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using UE = UnityEngine;

namespace SDFormat
{
    namespace Helper
    {
        public class MyElement : Base
        {
            [UE.Header("SDF Properties")]
            public string myProperty;

            new protected void Awake()
            {
                base.Awake();
                // Element-specific initialization
            }

            new protected void Start()
            {
                base.Start();
                // Element-specific startup
            }

            // Override if this element has runtime state to reset
            // public new void Reset()
            // {
            //     base.Reset();
            // }
        }
    }
}

// In ImportLinks() or ImportModels():
ImportMyElements(model.MyElements, newModelObject);

// Store during import:
protected void StoreMyElements(IReadOnlyList<MyElement> items, in object parentObject)
{
    foreach (var item in items)
    {
        _myElementObjectList.Add(item, parentObject);
    }
}

// Process later in Start():
private void ImportDeferredMyElements()
{
    foreach (var item in _myElementObjectList)
    {
        ImportMyElement(item.Key, item.Value);
    }
}