std::future,std::asyncを使った非同期で読み込んだ画像が描画されない原因が知りたい

Question

質問内容

提示コードのvoid Engine::SpriteRenderer::Render()関数部ですがSDL_Texture* texture = IMG_LoadTexture(Context::GetRenderer(),"./tile4.png");を使うと正常に描画できるのですがsprite.handleを使って描画すると描画されません。これはなぜでしょうか？　非同期で画像ロードしてしっかりと待機していて同じポインターを指しているのですが原因がわかりません。デストラクタ等は定義、宣言していません。

知りたいこと

画像が描画できない原因が知りたい

確認したいこと

SDL_GetError()を実行しましたが何も表示されていません。

#ソースコード　全文

画像ロード関数

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

struct Sprite
{
    SDL_Texture *handle;
    std::string path;
};


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

std::chrono::_V2::system_clock::time_point startTime;

void SetStartTime()
{
    startTime = std::chrono::high_resolution_clock::now();
}

int GetEndTime()
{

    auto endTime = std::chrono::high_resolution_clock::now();
    auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

    return time.count();
}

/*##############################################################
# 乱数取得
##############################################################*/
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));
    SDL_Texture *texture = IMG_LoadTexture(Engine::Context::GetRenderer(),"tile4.jpg");

    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{texture, std::string(filePath) });
    //sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

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

    return sprites.back(); 
}

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

# 同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/


/*##############################################################
# Component 基底
##############################################################*/
class GameObject;
class Component
{
public:
    
GameObject *gameObject;
    Component(GameObject* g)
    {
        gameObject = g;
    }

    virtual std::vector<std::future<void>> PreLoad()
    {

        return std::move(futures);
    }


    virtual void Start() = 0;

    virtual void Update() = 0;

    virtual void Render()
    {
        
    }

protected:

    std::vector<std::future<void>> futures;
};
/*##############################################################
# GameObject 基底
##############################################################*/
class GameObject
{
public:

    GameObject()
    {

    }

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

        for(Component *c : components)
        {
            for(std::future<void> &f : c->PreLoad())
            {
                process.push_back(std::move(f));
            }
        }

        return std::move(process);
    }


    void Start()
    {
       for(Component* c : components)
       {
            c->Start();
       } 
    }
    void Update()
    {
        for(Component* c : components)
        {
            c->Update();
        } 
    }

    void Render()
    {
        for(Component* c : components)
        {
            c->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));
            }
        }


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

        int time = GetEndTime();
        std::cout<<time<<std::endl;
    }


    void Update()
    {
        for(GameObject *g : gameObjects)
        {
            g->Update();
        } 
    }

    void Render()
    {
        for(GameObject *g : gameObjects)
        {
            g->Render();
        } 
    }

 
};

/*##############################################################
# SpriteRenderer コンポーネント
##############################################################*/
class SpriteRenderer : public Component
{
public:

    Sprite sprite;
    SpriteRenderer(GameObject* g): Component(g)
    {

    }

    void Start() override
    {

    }

    void Update() override
    {

    }

    void Render() override
    {
        SDL_Texture* texture = IMG_LoadTexture(Engine::Context::GetRenderer(),"tile4.jpg");
        SDL_Rect rect =  {0,0,64,64};
        SDL_Rect dest =  {100,100,64,64};

        //std::cout<<"Render"<<std::endl;
        //SDL_RenderCopy(Engine::Context::GetRenderer(),texture,&rect,&dest);
        SDL_RenderCopy(Engine::Context::GetRenderer(),sprite.handle,&rect,&dest);
        //SDL_RenderCopy(Engine::Context::GetRenderer(),sprite.handle,&rect,&dest);

        std::cout<<SDL_GetError()<<std::endl;
    }
};


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

    std::vector<std::future<void>> PreLoad() override
    {

    
        futures.push_back(std::async(std::launch::async,[this](){ ((SpriteRenderer*)(gameObject->components.at(0)))->sprite = LoadSprite("tile4.jpg");  }));



       return std::move(futures); 
    }

    void Start()
    {

    }

    void Update()
    {

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



    
};




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


    void PreLoad()
    {
        for(std::future<void> &f : gameObjects.at(0)->getPreLoad())
        {
            f.wait();
        }   
    }

    void Start()
    {
        gameObjects.at(0)->Start();
    }

    void Update()
    {

        gameObjects.at(0)->Update();
    }

    void Render()
    {
        gameObjects.at(0)->Render();
    }
};




int main()
{
    Engine::Context::Init("Game",glm::ivec2(680,480));
    Game *g = new Game();

    g->PreLoad();

        g->Start();
    while(true)
    {
        Engine::Context::ClearBuffer();
        if(Engine::Context::GetKey(SDL_SCANCODE_ESCAPE) == true)
        {
            break;
        }


        g->Update();
        g->Render();

        Engine::Context::RenderBuffer();
    }


    Engine::Context::Finalize();
    return 0;
}

Comments

[hiroki-o]

手元の環境で再現して調査しようとしていますが、苦戦しています。
もし、お手数でなければ教えてください。
(一般的なstd::asyncの話として考えてほしい、というなら結構です)

1. OSとC++コンパイラは何を使用していますか？
2. Context.hppは、https://www.sfml-dev.org/index.php のSFMLでしょうか？
3. glmは、https://github.com/icaven/glm でしょうか？
4. SDLは、https://github.com/libsdl-org/SDL でしょうか？ また、#include <SDL.h>は不要ですか？
5. IMG_LoadTextureクラス、Engineクラスは、どのヘッダーに属するクラスでしょうか？

[fana]

全く知らない物の話なので的外れかとも思いますが……
まず，やろうとしている処理というのがそもそもマルチスレッドで（というか「メインでないスレッドで」とでもいうか？）実施可能な処理なのか？　というあたりは大丈夫なのでしょうか？

例えば……
確か，OpenGLのレンダリングコンテキストはスレッド固有みたいな扱いだったと記憶しています．
お使いのライブラリ(SDL?)に，それと似たような何らかの事柄が存在していたりはしないのだろうか？　とか，ちょっと思いました．
（SDLというやつが裏で何を（OpenGL? DirectX? その他？）用いているのか等全く知りませんが，SDLがそういったところを仕様として面倒見てくれる（マルチスレッドOKと保証してくれる）物なのだろうか？　…みたいな？）

Answer 1

どうやらマルチスレッドでの処理の場合は以下の専用の処理が必要みたいです

原因

専用の処理を書く必要がある

参考サイト

参考サイト：https://www.libsdl.org/release/SDL-1.2.15/docs/html/thread.html