Best way to associate Svelto Components with UnityGameObject

[lovepurple]

When creating UnityGameObject, it needs to be registered in OOPManager, and then SyncGameObject Render in xxxEngine is more convenient. Then there is a problem that when registering in OOPManager, it needs to return a globally unique ID, but When operating Svelto's Component in xxxEngine, the unique ID cannot be obtained, because the unique ID of GameObject is not recorded in Svelto's Component. What should I do in this situation? Because the Components obtained through entitiesDB.QueryEntities<> in xxxEngine are not I don't know which UnityGameObject it is.

Here's a concrete example: I want to operate the alpha value of a game object.

FadeoutComponent.cs

using Svelto.ECS;
public struct FadeoutComponent : IEntityComponent
{
    public float AlphaValue;
}

OOPManager.cs

using Svelto.DataStructures;
using UnityEngine;

public class OOPManager 
{
    public FasterList<GameObject> m_gameObjects = new FasterList<GameObject>();

    public uint RegisterGameObject(GameObject gameObject)
    {
        m_gameObjects.Add(gameObject);
        return (uint)m_gameObjects.count;
    }

    public void SetRenderAlpha(uint gameObjectId, float alphaValue)
    {
        Color color = m_gameObjects[gameObjectId].GetComponentInChildren<SkinnedMeshRenderer>().sharedMaterial.GetColor("_Color");
        m_gameObjects[gameObjectId].GetComponentInChildren<SkinnedMeshRenderer>().sharedMaterial.SetColor("_Color", new Color(color.r, color.g, color.b, alphaValue));
    }
}

InputEngine.cs

using Svelto.ECS;
using Svelto.ECS.SveltoOnDOTS;
using System.Collections;
using System.Collections.Generic;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

public class InputEngine : IJobifiedEngine, IQueryingEntitiesEngine
{
    private IEntityFactory m_entityFactory;
    public InputEngine(IEntityFactory entityFactory)
    {
        this.m_entityFactory = entityFactory;
    }
    public string name => "InputEngine";

    public EntitiesDB entitiesDB { private get; set; }

    private JobHandle m_jobHandle;  

    public JobHandle Execute(JobHandle inputDeps)
    {
        this.m_jobHandle = inputDeps;
        DetectInput();
        return m_jobHandle;

    }

    private void DetectInput()
    {
        if (Input.GetKeyDown(KeyCode.F))
        {
            var (fadeoutComponents, componentCount) = entitiesDB.QueryEntities<FadeoutComponent>(MainPlayerTag.BuildGroup);
            for (int i = 0; i < componentCount; ++i)
                fadeoutComponents[i].AlphaValue = 0.8f;
        }
    }

    private void SpawnMainPlayer()
    {
        var s = MainPlayerTag.BuildGroup;
        EntityInitializer entityInitializer = this.m_entityFactory.BuildEntity<PlayerEntityDescriptor>(0, MainPlayerTag.BuildGroup);
        entityInitializer.Init<GameObjectComponent>(new GameObjectComponent());
        entityInitializer.Init<PositionComponent>(new PositionComponent() { Position = new float3(0, 0, 0) });
        entityInitializer.Init<FadeoutComponent>(new FadeoutComponent() { AlphaValue = 1 });

    }

    public void Ready()
    {
    }
}

PlayerFadeoutHandleEngine.cs

using Svelto.ECS;

public class PlayerFadeoutEngine : IQueryingEntitiesEngine
{
    public string name => "PlayerFadeoutEngine";

    private readonly OOPManager m_oopManager;

    public PlayerFadeoutEngine(OOPManager oOPManager)
    {
        this.m_oopManager = oOPManager;
    }

    public EntitiesDB entitiesDB { private get; set; }

    public void Ready()
    {

    }

    public void Step()
    {
        var (components, count) = entitiesDB.QueryEntities<FadeoutComponent>(PlayerTag.BuildGroup);
        for (int i = 0; i < count; ++i)
        {
            **//How to retrieve the corresponding game object or unity component ??**
            this.m_oopManager.SetRenderAlpha( **??????** , components[i].AlphaValue);
        }
    }
}

My question is in the last line, what do I need to do to retrieve the corresponding UnityObject through the FadeoutComponent.

[cathei]

You can make a component that holds unique id of game object, such as ObjectIndexComponent here. (Maybe your GameObjectComponent is doing the same thing?)

public struct ObjectIndexComponent : IEntityComponent
{
    public          uint          index;
    public readonly PrimitiveType type;

    public ObjectIndexComponent(PrimitiveType type) : this() { this.type = type; }
}

Which can be assigned when GameObject is created. Such as here in SyncEntityCreation Engine.

public void Add(ref ObjectIndexComponent entityComponent, EGID egid)
{
    entityComponent.index = _oopManager.RegisterEntity(entityComponent.type);
}

Then query both ObjectIndexComponent and FadeoutComponent from PlayerFadeoutEngine, so you can obtain both global ID and fade component.

public void Step()
{
    var (objectIndex, fadeout, count) = entitiesDB.QueryEntities<ObjectIndexComponent, FadeoutComponent>(PlayerTag.BuildGroup);
    for (int i = 0; i < count; ++i)
    {
        this.m_oopManager.SetRenderAlpha(objectIndex[i].index, fadeout[i].AlphaValue);
    }
}

[lovepurple]

Thanks cathei. I forgot there is this feature, which can be combined to query multiple Components at the same time, and the results of the query are one-to-one correspondence, which is easy to deal with.

[lovepurple]

My solution is as follows.

1. Add a GameObjectComponent.cs storage the gameobject uniqueid

using Svelto.ECS;
using Svelto.ECS.Experimental;

public struct GameObjectComponent : IEntityComponent
{
    public ECSString Name { get; set; }
    public uint ObjectUniqueId { get; set; }
}

2. OOPManager.cs implement the interface IReactOnAdd

using Svelto.DataStructures;
using Svelto.ECS;
using UnityEngine;

public class OOPManager : IReactOnAdd<GameObjectComponent>, IGetReadyEngine
{
    public FasterList<GameObject> m_gameObjects = new FasterList<GameObject>();

    public void Add(ref GameObjectComponent entityComponent, EGID egid)
    {
        GameObject playerObj = this.m_gameObjectManager.InstantiateGameObject(0);
        entityComponent.ObjectUniqueId = RegisterGameObject(playerObj);
    }

    public void Ready()
    {

    }

    private uint RegisterGameObject(GameObject gameObject)
    {
        m_gameObjects.Add(gameObject);
        return (uint)m_gameObjects.count - 1;
    }

    // Start is called before the first frame update
    public void SetRenderAlpha(uint gameObjectId, float alphaValue)
    {
        Color color = m_gameObjects[gameObjectId].GetComponentInChildren<SkinnedMeshRenderer>().sharedMaterial.GetColor("_Color");
        m_gameObjects[gameObjectId].GetComponentInChildren<SkinnedMeshRenderer>().sharedMaterial.SetColor("_Color", new Color(color.r, color.g, color.b, alphaValue));
    }

    private IEntityFactory m_globalEntityFactory = null;
    private UnityGameObjectManager m_gameObjectManager = null;

    public string name => "OOPManager";

    public OOPManager(IEntityFactory entityFactory, UnityGameObjectManager unityGameObjectManager)
    {
        this.m_globalEntityFactory = entityFactory;
        this.m_gameObjectManager = unityGameObjectManager;
    }
}

3. PlayerFadeoutEngine.cs

using Svelto.ECS;
using Svelto.ECS.SveltoOnDOTS;
using Unity.Jobs;

public class PlayerFadeoutEngine : IQueryingEntitiesEngine, IJobifiedEngine
{
    public string name => "PlayerFadeoutEngine";

    private readonly OOPManager m_oopManager;

    public PlayerFadeoutEngine(OOPManager oOPManager)
    {
        this.m_oopManager = oOPManager;
    }

    public EntitiesDB entitiesDB { private get; set; }

    public void Ready()
    {

    }



    public JobHandle Execute(JobHandle inputDeps)
    {
        var (fadeoutComponents, gameObjectComponents, count) = entitiesDB.QueryEntities<FadeoutComponent, GameObjectComponent>(PlayerTag.BuildGroup);
        for (int i = 0; i < count; ++i)
        {
            this.m_oopManager.SetRenderAlpha(gameObjectComponents[i].ObjectUniqueId, fadeoutComponents[i].AlphaValue);
        }
        return inputDeps;
    }
}