Discussion :

[KevinduC]

Bonjour, j'essaie encore de m'initier à Vulkan, OpenGL étant déprécié depuis 2016 ça devient un peu vieux. Je suis donc le tuto sur ce site mais quelque chose m'intrigue : Le tuto explique comment créer un seul rendu, mais moi je peux avoir besoin de plusieurs tampons de sommets et plusieurs pipelines et le tuto n'explique visiblement pas (Sauf erreur de ma part) comment gérer cela. J'ai tenté quelque chose en bricolant : Au lieu d'avoir une unique instance de VkPipeline, j'ai créé une structure "Pipeline" contenant une instance de VkPipeline et une string pour le nom du shader associé, puis un tableau de "Pipeline" dans la classe principale. J'ai ensuite mis le chargement de chaque pipeline dans une boucle, ce qui en simplifiant donne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
void Vulkan::createGraphicsPipeline()
{
    for(unsigned int i=0;i<pipelines.size();i++)		//"pipelines" est le tableau de "Pipeline", préalablement redimensionné
    {
        std::string vert="Shaders/"+pipelines[i].shaderName+".vert.spv";
        std::string geom="Shaders/"+pipelines[i].shaderName+".geom.spv";
        std::string frag="Shaders/"+pipelines[i].shaderName+".frag.spv";
 
        auto vertShaderCode = readFile(vert);
        auto geomShaderCode = readFile(geom);
        auto fragShaderCode = readFile(frag);
 
        VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
 
        ...
 
        //////////////////////////////
 
        VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
        vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
        vertShaderStageInfo.module = vertShaderModule;
        vertShaderStageInfo.pName = "main";
 
        ...
 
        //////////////////////////////
 
        VkPipelineShaderStageCreateInfo shaderStages[3];
 
        if(geomShaderCode.size()==0)
        {
            shaderStages[0]=vertShaderStageInfo;
            shaderStages[1]=fragShaderStageInfo;
        }
        else
        {
            shaderStages[0]=vertShaderStageInfo;
            shaderStages[1]=geomShaderStageInfo;
            shaderStages[2]=fragShaderStageInfo;
        }
 
        //////////////////////////////
 
        VkPipelineVertexInputStateCreateInfo vertexInputInfo{};             //Sommets en entrée
 
		...
 
        //////////////////////////////
 
        VkPipelineInputAssemblyStateCreateInfo inputAssembly{};             //Assembleur d'entrée
 
		...
 
        //////////////////////////////
 
        VkViewport viewport{};      //Viewport
 
		...
 
        ////
 
        VkRect2D scissor{};         //Scissor
 
		...
 
        ////
 
        VkPipelineViewportStateCreateInfo viewportState{};
 
		...
 
        //////////////////////////////
 
        VkPipelineRasterizationStateCreateInfo rasterizer{};        //Rastériseur
 
		...
 
        //////////////////////////////
 
        VkPipelineMultisampleStateCreateInfo multisampling{};
 
		...
 
        //////////////////////////////
 
        VkPipelineColorBlendAttachmentState colorBlendAttachment{};
 
		...
 
        VkPipelineColorBlendStateCreateInfo colorBlending{};
 
		...
 
        //////////////////////////////
 
        VkDynamicState dynamicStates[] =
        {
            VK_DYNAMIC_STATE_VIEWPORT,
            VK_DYNAMIC_STATE_LINE_WIDTH
        };
 
        VkPipelineDynamicStateCreateInfo dynamicState{};
 
		...
 
        //////////////////////////////
 
        VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
 
		...
 
        if(vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS)
        {
            throw std::runtime_error("Échec lors de la création de l’agencement du pipeline !");
        }
 
        std::cout << "Pipeline agency OK" << std::endl;
 
        //////////////////////////////
 
        VkGraphicsPipelineCreateInfo pipelineInfo{};
 
		...
 
        //////////////////////////////
 
        if(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipelines[i].graphicsPipeline) != VK_SUCCESS)
        {
            throw std::runtime_error("Échec pour créer le pipeline graphique !");
        }
 
        std::cout << "Pipeline OK" << std::endl;
 
        //////////////////////////////
 
        vkDestroyShaderModule(device, vertShaderModule, nullptr);
 
        if(geomShaderCode.size()!=0)
            vkDestroyShaderModule(device, geomShaderModule, nullptr);
 
        vkDestroyShaderModule(device, fragShaderModule, nullptr);
    }
}

Côté rendu je fais ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
void Vulkan::drawFrame(const unsigned int index)		//J'ai ajouté ce paramètre "index" pour savoir quel pipeline sélectionner
{
    vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
 
    uint32_t imageIndex;
    vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
 
    VkPipelineBindPoint bindPoint;
 
    vkCmdBindPipeline(commandBuffers[imageIndex],bindPoint,pipelines[index].graphicsPipeline);		//Sélection du pipeline ici mais ça crash
 
    if(imagesInFlight[imageIndex] != VK_NULL_HANDLE)
    {
        vkWaitForFences(device, 1, &imagesInFlight[imageIndex], VK_TRUE, UINT64_MAX);
    }
 
    imagesInFlight[imageIndex] = inFlightFences[currentFrame];
 
    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 
    VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};
    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
 
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &commandBuffers[imageIndex];
 
    VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[currentFrame]};
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;
 
    vkResetFences(device, 1, &inFlightFences[currentFrame]);
 
    if(vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS)
    {
        throw std::runtime_error("Échec d’envoi du tampon de commandes pour le rendu !");
    }
 
    VkPresentInfoKHR presentInfo{};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
 
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;
 
    VkSwapchainKHR swapChains[] = {swapChain};
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
    presentInfo.pImageIndices = &imageIndex;
 
    vkQueuePresentKHR(presentQueue, &presentInfo);
 
    vkQueueWaitIdle(presentQueue);
 
    currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}

Mais le programme bug alors, vous qui êtes parvenu à faire le grand saut OpenGL => Vulkan pourriez-vous m'aiguiller là-dessus svp ? Comment faire plusieurs rendus, autrement dit l'équivalent de glBindBuffer() et glUseProgram() ? Merci par avance, j'aimerais avancer car enfin je suis parvenu à avoir un premier rendu Vulkan mais je suis de nouveau bloqué et encore contraint de me replier vers OpenGL

[dragonjoker59]

Salut !

Ta variable bindPoint n'est pas initialisée, ça peut expliquer ton crash.

Tu as activé les validation layers ?

EDIT:

Par contre, il ne te faut pas un pipeline par vertex buffer.