Function PostUpdate

engine/gameobject/src/gameobject/gameobject.cpp:2898–2982

    }

    static bool PostUpdate(Collection* collection)
    {
        DM_PROFILE("PostUpdate");
        assert(collection != 0x0);
        HRegister reg = collection->m_Register;
        assert(reg);

        bool result = true;

        uint32_t component_types = reg->m_ComponentTypeCount;
        for (uint32_t i = 0; i < component_types; ++i)
        {
            uint16_t update_index = reg->m_ComponentTypesOrder[i];
            ComponentType* component_type = &reg->m_ComponentTypes[update_index];

            if (component_type->m_PostUpdateFunction)
            {
                DM_PROFILE_DYN(component_type->m_Name, 0);
                ComponentsPostUpdateParams params;
                params.m_Collection = collection->m_HCollection;
                params.m_World = collection->m_ComponentWorlds[update_index];
                params.m_Context = component_type->m_Context;
                UpdateResult res = component_type->m_PostUpdateFunction(params);
                if (res != UPDATE_RESULT_OK && result)
                    result = false;
            }
        }

        uint32_t instances_deleted = 0;

        if (collection->m_InstancesToDeleteHead != INVALID_INSTANCE_INDEX) {
            // Arbitrary max pass count to only guard for unexpected cycles and infinite hangs, see clause after while
            uint32_t max_pass_count = 10;
            uint32_t pass_count = 0;
            while (collection->m_InstancesToDeleteHead != INVALID_INSTANCE_INDEX && pass_count < max_pass_count) {
                ++pass_count;
                // Save the list and clear the head and tail
                uint16_t head = collection->m_InstancesToDeleteHead;
                collection->m_InstancesToDeleteHead = INVALID_INSTANCE_INDEX;
                collection->m_InstancesToDeleteTail = INVALID_INSTANCE_INDEX;

                uint16_t index = head;
                while (index != INVALID_INSTANCE_INDEX) {
                    Instance* instance = collection->m_Instances[index];

                    assert(collection->m_Instances[instance->m_Index] == instance);
                    assert(instance->m_ToBeDeleted);
                    if (instance->m_Initialized) {
                        if (!FinalInstance(collection, instance) && result) {
                            result = false;
                        }
                    }
                    index = instance->m_NextToDelete;
                }

                if (!DispatchAllSockets(collection)) {
                    result = false;
                }