Utilisation avancée des processeurs graphiques avec Qt

Utilisation avancée des processeurs graphiques avec Qt par Rémi Achard Guillaume Belz
cl
sum_normal += getNormal(in, vector_plan, pos);
}
sum_normal = normalize(sum_normal);
//sum_normal.w = 1.0;
return sum_normal;
}
//-----------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------
__kernel void NormalsUpdate(
__global const float4* in, // int points vector
__global float4* out, // out normals vector
const int size, // size of vectors
const int width) // map width
{
const int global_id = get_global_id(0);
if (global_id < size)
{
out[global_id] = getSumNormal(in, global_id, width);
}
}
5.3.3 - Partager des données entre OpenCL et OpenGL
Dans la partie précédente, nous avons acceléré le calcul des normales en utilisant le GPU. Néanmoins, il est
dommage de devoir récupéré le buffer de résultat d'OpenCL, depuis le GPU vers le CPU, pour le renvoyer ensuite
au GPU dans un VBO.
OpenCL dispose d'une fonctionnalité interessante dans notre cas : le partage de contexte entre OpenGL et OpenCL.
En utilisant cette fonctionnalité, il est possible de stocker directement les résultats d'OpenCL dans le VBO contenant
les normales, nous évitant un allé-retour vers la mémoire système inutile.
Le partage OpenCL / OpenGL est implémenté à l'aide de la classe QCLContextGL. Un contexte OpenGL doit être
actif à la création du contexte CL/GL. Ce partage de données entre les deux contextes necessite la présence d'une
extension OpenCL : cl_khr_gl_sharing. Sa présence peut être testée avec la fonction supportsObjectSharing() de
la classe QCLContextGL.
cpp
QCLContextGL GPUContextGL&nbsp;;
makeCurrent();
if(!GPUContextGL.create())
qFatal("Could not create OpenCL / OpenGL context");
Outre le changement de contexte (QCLContext vers QCLContextGL), les différences par rapport au programme de
la partie précédente apparaissent au niveau de la création et libération des buffers. Existant déjà coté GPU sous la
forme de VBO, seul des pointeurs vers ces buffers seront récupérés.
La fonction createGLBuffer() de la classe QCLContextGL récupère le pointeur vers un buffer OpenGL grâce à son
identifiant (obtenu avec la fonction bufferId() de la classe QGLBuffer).
cpp
QCLBuffer gpu_in_vector = GPUContextGL.createGLBuffer(vertex_buffer.bufferId(),
QCLMemoryObject::ReadOnly);
QCLBuffer gpu_out_vector = GPUContextGL.createGLBuffer(normal_buffer.bufferId(),
QCLMemoryObject::ReadWrite);
Avant d'effectuer tout type d'opération à l'aide d'OpenCL sur ces buffers, il est impératif d'appeler la méthode acquire().
- 76 -
http://gbelz.developpez.com/remi-achard/gpu-avance-avec-qt/modified/