Function CreateResource

engine/resource/src/resource_preloader.cpp:517–676

CreateResource operation ends either with 1) Having created the resource and free:d all buffers => RESULT_OK + m_Resource 2) Having failed, (or created and destroyed), leaving => RESULT_SOME_ERROR + everything free:d If buffer is null it means to use the items internal buffer

    //
    // If buffer is null it means to use the items internal buffer
    static void CreateResource(HPreloader preloader, PreloadRequest* req, void* buffer, uint32_t buffer_size, uint32_t resource_size)
    {
        assert(req->m_LoadResult == RESULT_PENDING);
        assert(req->m_PendingChildCount == 0);

        assert(req->m_PathDescriptor.m_ResourceType);

        ResourceDescriptor tmp_resource;
        memset(&tmp_resource, 0, sizeof(tmp_resource));

        ResourceType* resource_type = req->m_PathDescriptor.m_ResourceType;

        // We must call CreateFunction if Preload function has been called, so always do this even when an error has occured
        tmp_resource.m_NameHash       = req->m_PathDescriptor.m_CanonicalPathHash;
        tmp_resource.m_ReferenceCount = 1;
        tmp_resource.m_ResourceType   = resource_type;

        ResourceCreateParams params;
        params.m_Factory     = preloader->m_Factory;
        params.m_Type        = resource_type;
        params.m_Context     = resource_type->m_Context;
        params.m_PreloadData = req->m_PreloadData;
        params.m_Resource    = &tmp_resource;
        params.m_Filename    = req->m_PathDescriptor.m_InternalizedName;
        params.m_FileSize                 = req->m_FileSize;

        if (!buffer)
        {
            assert(req->m_Buffer);
            tmp_resource.m_ResourceSizeOnDisc = req->m_BufferSize;
            params.m_Buffer                   = req->m_Buffer;
            params.m_BufferSize               = req->m_BufferSize;
            params.m_FileSize                 = req->m_FileSize;
            params.m_IsBufferPartial          = req->m_BufferSize != req->m_FileSize;
            req->m_LoadResult                 = (Result)resource_type->m_CreateFunction(&params);

            dmBlockAllocator::Free(preloader->m_BlockAllocator, req->m_Buffer, req->m_BufferSize);

            req->m_Buffer = 0;
        }
        else
        {
            tmp_resource.m_ResourceSizeOnDisc = buffer_size;
            params.m_Buffer                   = buffer;
            params.m_BufferSize               = buffer_size;
            params.m_FileSize                 = resource_size;
            params.m_IsBufferPartial          = buffer_size != resource_size;
            req->m_LoadResult                 = (Result)resource_type->m_CreateFunction(&params);
        }

        if (req->m_LoadResult == RESULT_OK)
        {
            if (resource_type->m_PostCreateFunction)
            {
                if (preloader->m_PostCreateCallbacks.Full())
                {
                    preloader->m_PostCreateCallbacks.OffsetCapacity(MAX_PRELOADER_REQUESTS / 8);
                }