Scripting

• C#으로 작성한 코드 컴파일 및 실행
• C++ 엔진 코드와 C# 간의 양방향 호출 (바인딩)
• C# 클래스의 메서드나 속성 접근
• 스크립트 클래스에서 엔진 Entity에 접근하거나 이벤트 수신

사용자는 Player.cs, Camera.cs 같은 C# 클래스를 작성한 후, 이를 DLL로 컴파일한다. 이 DLL은 엔진이 실행될 때 로딩된다. 모든 스크립트 클래스는 Entity 클래스를 상속받으며, onCreate(), onUpdate(float ts) 등의 메서드를 구현해야 한다는 규칙을 따른다. 또한 스크립트에서 사용하는 규칙(자료형, 클래스)을 따로 정의해 이를 DLL로 컴파일한다.

``` csharp

namespace Sandbox
{
    public class Player : Entity
    {
        void onCreate()
        {
        }

        void onUpdate(float ts)
        {
        }
    }
}

namespace ALEngine
{
    public struct Vector2
    {
        public float X, Y;

        public static Vector2 Zero => new Vector2(0.0f);
        
        // ...
    }

    public struct Vector3
    {
        public float X, Y, Z;

        public static Vector3 Zero => new Vector3(0.0f);

        // ...
    }
}

```

엔진은 시작 시 C# DLL을 Mono를 통해 로딩하고, 내부에 포함된 모든 클래스 정보를 수집한다. 이 과정에서 클래스 이름, 메서드 포인터, 필드 정보 등이 ScriptClass 객체에 저장된다. 이는 나중에 Entity와 연결될 때 사용된다.

``` csharp

    // Metadata를 나타내는 구조체 - 타입, 메서드, 필드 정보 등을 포함.
    const MonoTableInfo *typeDefsTable = mono_image_get_table_info(s_Data->appAssemblyImage, MONO_TABLE_TYPEDEF);
    int32_t numTypes = mono_table_info_get_rows(typeDefsTable);
    MonoClass *entityClass = mono_class_from_name(s_Data->coreAssemblyImage, "ALEngine", "Entity");

    for (int32_t i = 0; i < numTypes; ++i)
    {
        uint32_t cols[MONO_TYPEDEF_SIZE]; // 6
        mono_metadata_decode_row(typeDefsTable, i, cols, MONO_TYPEDEF_SIZE);

        const char *nameSpace = mono_metadata_string_heap(s_Data->appAssemblyImage, cols[MONO_TYPEDEF_NAMESPACE]);
        const char *className = mono_metadata_string_heap(s_Data->appAssemblyImage, cols[MONO_TYPEDEF_NAME]);
        std::string fullName;

        // C# Style
        if (strlen(nameSpace) != 0)
            fullName = fmt::format("{}.{}", nameSpace, className);
        else
            fullName = className;

        MonoClass *monoClass = mono_class_from_name(s_Data->appAssemblyImage, nameSpace, className);

        // ScriptCore에 정의한 Class와 일치.
        if (monoClass == entityClass)
            continue;

        // Class 계층 구조 검사, 부모-자식 관계 확인
        bool isEntity = mono_class_is_subclass_of(monoClass, entityClass, false);
        if (!isEntity)
            continue;

        std::shared_ptr<ScriptClass> scriptClass = std::make_shared<ScriptClass>(nameSpace, className);
        s_Data->entityClasses[fullName] = scriptClass;

        // check class fields
        int32_t fieldCount = mono_class_num_fields(monoClass);
        void *iterator = nullptr;
        while (MonoClassField *field = mono_class_get_fields(monoClass, &iterator))
        {
            const char *fieldName = mono_field_get_name(field); // variable name
            uint32_t flags = mono_field_get_flags(field);
            if (flags & MONO_FIELD_ATTR_PUBLIC)
            {
                MonoType *type = mono_field_get_type(field); // variable type
                EScriptFieldType fieldType = utils::monoTypeToScriptFieldType(type);
                scriptClass->m_Fields[fieldName] = {fieldType, fieldName, field};
            }
        }
    }
}

```

Scene이 로드되면, 모든 Entity를 순회하며 ScriptComponent가 있는지를 확인한다. 만약 해당 컴포넌트의 클래스 이름이 사전에 등록된 ScriptClass와 일치한다면, 해당 C# 클래스의 인스턴스를 생성한다.

``` cpp

void ScriptingEngine::onCreateEntity(Entity entity)
{
    const auto &sc = entity.getComponent<ScriptComponent>();
    if (ScriptingEngine::entityClassExists(sc.m_ClassName))
    {
        UUID entityID = entity.getUUID();

        std::shared_ptr<ScriptInstance> instance =
            std::make_shared<ScriptInstance>(s_Data->entityClasses[sc.m_ClassName], entity);

        s_Data->entityInstances[entityID] = instance;

        // Copy field values
        if (s_Data->entityScriptFields.find(entityID) != s_Data->entityScriptFields.end())
        {
            const ScriptFieldMap &fieldMap = s_Data->entityScriptFields.at(entityID);
            for (const auto &[name, fieldInstance] : fieldMap)
                instance->setFieldValueInternal(name, fieldInstance.m_Buffer);
        }
        instance->invokeOnCreate();
    }
}

```

생성된 인스턴스에 대해 onCreate()가 한 번 호출되며, 매 프레임마다 onUpdate(ts) 메서드가 호출된다. 이 때 ts는 프레임 간 시간 간격으로, 엔진이 매 프레임 전달한다. ScriptInstance는 특정 Entity에 연결된 C# 인스턴스를 관리한다. 현재는 C++에서 스크립트를 제어하는 단방향 구조이지만, 향후 C# 측에서도 엔진 Entity를 조작할 수 있도록 래퍼 클래스를 제공하는 방식으로 확장할 수 있다.

``` cpp

void ScriptingEngine::onUpdateEntity(Entity entity, Timestep ts)
{
    UUID entityID = entity.getUUID();

    // Runtime중 삭제될 수 있기 때문에 check needed.
    if (s_Data->entityInstances.find(entityID) != s_Data->entityInstances.end())
    {
        std::shared_ptr<ScriptInstance> instance = s_Data->entityInstances[entityID];
        instance->invokeOnUpdate((float)ts);
    }
    else
    {
        AL_CORE_ERROR("Could not find ScriptInstance for entity {}", entityID);
    }
}

```

C# 스크립트에서 엔진 기능을 직접 호출할 수 있도록 Mono의 internal call 기능을 사용해 주요 엔진 API를 바인딩했다. 예를 들어 getComponent<T>(), addForce(Vector3 force)와 같은 함수들은 C++ 측 엔진 함수와 연결되어 있으며, 스크립트에서 직접 사용할 수 있다.

``` csharp

namespace ALEngine
{
    // ...

    public class RigidbodyComponent : Component
    {
        public void addForce(Vector3 force)
        {
            InternalCalls.RigidbodyComponent_addForce(Entity.ID, ref force);
        }
    }

    // ...
}

namespace ALEngine
{
    public static class InternalCalls
    {
        // ...

        #region RigidbodyComponent
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static void RigidbodyComponent_addForce(ulong entityID, ref Vector3 force);
        #endregion
        
        // ...
    }
}

```


``` cpp

// ALEngine API
static void RigidbodyComponent_addForce(UUID entityID, glm::vec3 *force)
{
    Scene *scene = ScriptingEngine::getSceneContext();
    Entity entity = scene->getEntityByUUID(entityID);

    Rigidbody *body = (Rigidbody *)entity.getComponent<RigidbodyComponent>().body;
    body->registerForce(*force);
}


```