[ゲーム開発] 非同期のアセットのロードで同じファイルがロードされない仕組みを作りたい

Question

質問内容

提示コードですが非同期処理を用いて、アセットを非同期でロードする処理なのですが現状３つの画像がそれぞれ順番にロードされてしまう原因が知りたいです。
提示コードの非同期版のコードでは同じ画像が来た時待機するという処理を行っているのですが、なぜか同期版と同じ秒数処理時間がかかっているため同期処理と同じになって
いると考えられます。

調べたこと

非同期版と同期版両方のプログラムを記述して実行時間を計測

知りたいこと

１，アセットのロードで同じファイルがロードされないようにしながら非同期で行いたい。
２，そもそもどの非同期機能を使ってアセットロードを実装するのが定番なのか知りたいです。

提示コードについて

提示コードはコンポーネント指向を用いています。Componentを継承して非同期で行うアセットロード処理を作り、それをGameObject(コンポーネントをの挙動を管理する)で
処理をまとめて、更に上のSceneで全部のGameObject の非同期処理を一つにまとめ、最後に全部が終わるまで待機してからUpdate()等を実行するという処理内容です。

コンソール

new sprite
found sprite
new sprite
2000

ソースコード

#include <vector>
#include <future>
#include <iostream>
#include <glm/glm.hpp>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <random>
#include <thread>

struct Sprite
{
    int handle;
    std::string path;
};


std::vector<Sprite> sprites;            //ロードした画像リスト
std::vector<std::string> nowLoad;       //現在ロード中の画像リスト 
std::mutex loadMutex;
std::condition_variable loadCV;


/*##############################################################
# 乱数取得
##############################################################*/
int GetRandom(int rand)
{
    // 現在の時間を取得して種(seed)として使用する
    auto now = std::chrono::high_resolution_clock::now();
    auto seed = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

    // 乱数生成器を初期化
    std::mt19937_64 generator(seed);

    // ミリ秒単位の乱数を生成
    std::uniform_int_distribution<int> distribution(0, rand);
    int random_number = distribution(generator);

    //std::cout << "ミリ秒単位の乱数: " << random_number << std::endl;

    return random_number;
}

/*##############################################################

# 非同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/
Sprite LoadSprite(const char* filePath)
{
    std::unique_lock<std::mutex> lock(loadMutex);

    // 他のスレッドが同じ画像をロード中であれば待機
    loadCV.wait(lock, [&filePath]() 
    {
        for(const std::string& path : nowLoad) 
        {
            if (path == std::string(filePath)) 
            {
                return false;
            }
        }
    
        return true;
    });

    //スプライトリストから取り出す
    for (const Sprite& s : sprites)
    {
        if (s.path == std::string(filePath))
        {
            std::cout << "found sprite" << std::endl;
            return s;
        }
    }

    std::cout << "new sprite" << std::endl;

    // ロード中の画像リストに追加
    nowLoad.push_back(std::string(filePath));
    lock.unlock();  // ロックを解除して他のスレッドがロードを開始できるようにする

    //画像ロード
    int milliseconds = 1000;
    //int milliseconds = GetRandom(1000);
    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));


    lock.lock();  // ロックを再取得して安全に状態を更新する


    //ロードが終わったためリストから削除
    int i = 0;
    for(const std::string& s : nowLoad)
    {
        if(s == filePath)
        {
           break; 
        }

        i++;
    }
    nowLoad.erase(nowLoad.begin() + i);

    //ロード済みスプライトリストに追加
    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

    // 画像のロードが完了したことを通知
    loadCV.notify_all();

    return sprites.back();

    
}

/*##############################################################

# 同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/
Sprite Sync_LoadSprite(const char* filePath)
{
   //スプライトリストから取り出す
    for (const Sprite& s : sprites)
    {
        if (s.path == std::string(filePath))
        {
            std::cout << "found sprite" << std::endl;
            return s;
        }
    }

    std::cout << "new sprite" << std::endl;

    //画像ロード
    int milliseconds =1000;
    //int milliseconds = GetRandom(1000);
    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));


   //ロード済みスプライトリストに追加
    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

    return sprites.back();

    
}





/*##############################################################
# Component 基底
##############################################################*/
class Component
{
public:
    
    Component()
    {

    }

    virtual void (*PreLoad())()
    {
        return []() -> void
        {
            std::cout<<"component"<<std::endl;
        };
    }
    
};
/*##############################################################
# GameObject 基底
##############################################################*/
class GameObject
{
public: 
    GameObject()
    {

    }

    std::vector<std::future<void>> getPreLoad()
    {
        std::vector<std::future<void>> futures;

        for(Component *c : components)
        {
            futures.push_back(std::async(std::launch::async,c->PreLoad()));
        }

        return futures;
    }

    void Update()
    {

    }

    void Render()
    {

    }

    std::vector<Component*> components;
};

/*##############################################################
# Scene 基底
##############################################################*/
class Scene
{
public: 

    std::vector<GameObject*> gameObjects;
    void Preaload()
    {
        std::vector<std::future<void>> futures;
        for(GameObject *g : gameObjects)
        {
            for(std::future<void> &f : g->getPreLoad())
            {
                futures.push_back(std::move(f));
            }
        }

        for(std::future<void> &f : futures)
        {
            f.wait();
        }
    }

};

/*##############################################################
# Control コンポーネント
##############################################################*/
class Control : public Component
{
public:
    Control(): Component()
    {
        
    }

    void (*PreLoad())() override
    {
        return []() ->void 
        {


// 同期
/*
            auto startTime = std::chrono::high_resolution_clock::now();
 
            Sprite sp1 = Sync_LoadSprite("tile1.jpg");
            Sprite sp2 = Sync_LoadSprite("tile1.jpg");
            Sprite sp3 = Sync_LoadSprite("tile2.jpg");
            
            auto endTime = std::chrono::high_resolution_clock::now();
            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

            std::cout<<time.count()<<std::endl;
*/

//非同期
            auto startTime = std::chrono::high_resolution_clock::now();
 
            Sprite sp1 = LoadSprite("tile1.jpg");
            Sprite sp2 = LoadSprite("tile1.jpg");
            Sprite sp3 = LoadSprite("tile2.jpg");
            
            auto endTime = std::chrono::high_resolution_clock::now();
            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

            std::cout<<time.count()<<std::endl;







        };
    }
};

/*##############################################################
# Player ゲームオブジェクト
##############################################################*/
class Player : public GameObject
{
public:
    Player(): GameObject()
    {
        components.push_back(new Control());
    }
};

/*##############################################################
# Game シーン
##############################################################*/
class Game : public Scene
{
public:
    Game(): Scene()
    {
        gameObjects.push_back(new Player());
    }
};




int main()
{

    Game *g = new Game();

    g->Preaload();



    return 0;
}

Comments

[maisumakun]

どのようなシチュエーションでしょうか？

（「最初のロードは同期処理で済ませて、その後は非同期で同じ画像を使い回す」では支障が出る状況なのですか？）

[samidare_chan]

そうですが、ゲーム開発なのですがアセットのロードは最初にまとめて行うとう処理が定番と聞いているのですが実際どうなのでしょうか？

Answer 1

ゲーム開発なのですがアセットのロードは最初にまとめて行うとう処理が定番と聞いているのですが実際どうなのでしょうか？

そうですね、ゲームのステージ中にロード処理が入ってしまうとゲーム体験を著しく損ねかねませんので、ステージが始まる前に必要な素材はすべてロードしておくのが妥当です。