Salut, j'essaye de compiler quelque kernels avec openCL malheureusement étant nouveau dans la manipulation de cette technologie, je ne m'y connais pas du tout en matière de syntaxe, je sais juste que c'est l'équivalent du C99 malheureusement je me retrouve avec des erreurs en compilation et des warnings dont je ne comprend absolument pas la signification.

Bref, voici le code :

Code cpp : 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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
            std::string prog = "#pragma OPENCL EXTENSION cl_khr_byte_addressable_store : enable\n"
                               "const int stepXSize = 4;\n"
                               "const int stepYSize = 4;\n"
                               "float16 multMat (float16 matA, float16 matB) {\n"
                                   "float16 matC;\n"
                                   "for (int x = 0; x < 4; ++x) {\n"
                                        "for (int y = 0; y < 4; ++y) {\n"
                                            "float value = 0;\n"
                                            "for (int k = 0; k < 4; ++k) {\n"
                                                "float elementA = matA[y * 4 + k];\n"
                                                "float elementB = matB[k * 4 + x];\n"
                                                "value += elementA * elementB;\n"
                                            "}\n"
                                            "matC[y * 4 + x] = value;\n"
                                        "}\n"
                                    "}\n"
                                    "return matC;\n"
                                "}\n"
                                "float4 addVec (float4 vecA, float4 vecB) {\n"
                                    "float4 result;\n"
                                    "for (int i = 0; i < 4; i++) {\n"
                                        "result[i] = vecA[i] + vecB[i];\n"
                                    "}\n"
                                    "return result;\n"
                                "}\n"
                                "float4 multVec (float vecA, float vecB) {\n"
                                    "float4 result;\n"
                                    "for (int i = 0; i < 4; i++) {\n"
                                        "result[i] = vecA[i] * vecB[i];\n"
                                    "}\n"
                                    "return result;\n"
                                "}\n"
                                "float4 multMatVec (float16 matA, float4 vecB) {\n"
                                   "float4 vecC;\n"
                                   "for (int i = 0; i < 4; ++i) {\n"
                                        "float value = 0;\n"
                                        "for (int j = 0; j < 4; ++j) {\n"
                                            "value += vecB[j] * matA[i][j];\n"
                                        "}\n"
                                        "vecC[i] = value;\n"
                                   "}\n"
                                   "return vecC;\n"
                                "}\n"
                                "float16 transpose(float16 matA) {\n"
                                    "float16 matT\n"
                                    "for (int i = 0; i < 4; ++i) {\n"
                                        "for (int j = 0; j < 4; ++j) {\n"
                                            "matT[i][j] = matA[j][i];\n"
                                        "}\n"
                                    "}\n"
                                    "return matT;\n"
                                "}\n"
                                "float  det (float4 mat) {\n"
                                    "return mat[0] * mat[2] - mat[1] * mat[3];\n"
                                "}\n"
                                "float min (float3 vec) {\n"
                                    "float cmin = vec.x;\n"
                                    "for (int i = 1; i < 3; ++i) {\n"
                                        "if (vec[i] < cmin)\n"
                                            "cmin = vec[i];\n"
                                    "}\n"
                                    "return cmin;\n"
                                "}\n"
                                "float max (float3 vec) {\n"
                                    "float cmax = vec.x;\n"
                                    "for (int i = 1; i < 3; ++i) {\n"
                                        "if (vec[i] > cmax)\n"
                                            "cmax = vec[i];\n"
                                    "}\n"
                                    "return cmax;\n"
                                "}\n"
                                "int equal(float4 v1, float4 v2) {\n"
                                    "return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;\n"
                                "}\n"
                                "float4 initEdge (const float2 v0, const float2 v1, const float2 origin, float4 oneStepX, float4 oneStepY) {\n"
 
                                       "int a = v0.y - v1.y, b = v1.x - v0.x;\n"
                                       "int c = v0.x*v1.y - v0.y*v1.x;\n"
 
                                       "oneStepX = (float4) (a * stepXSize, a * stepXSize, a * stepXSize, a * stepXSize);\n"
                                       "oneStepY = (float4) (b * stepYSize, b * stepYSize, b * stepYSize, b * stepYSize);\n"
 
                                       "float4 x = addVec(float4 (origin.x, origin.x, origin.x, origin.x), float4(0,1,2,3));\n"
                                       "float4 y = addVec(float4 (origin.y, origin.y, origin.y, origin.y), float4(0,1,2,3));\n"
 
                                       "return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));\n"
                                "}"
                                "__kernel void vertexShader(__global float* vPosX, __global float* vPosY, __global float* vPosZ, __global float* vPosW,\n"
                                                           "__global unsigned int* indices,  __global unsigned int numIndices, __global unsigned int* baseIndices,\n"
                                                           "__global unsigned int* baseVertices,  __global unsigned int* nbVerticesPerFace,\n"
                                                           "__global float* transfMatrices, __global float16 projMatrix, __global float16 viewMatrix,\n"
                                                           "__global float16 viewportMatrix) {\n"
                                    "size_t tid = get_global_id(0);\n"
                                    "int instanceID = tid / nbVerticesPerFace[0];\n"
                                    "int offset = tid % nbVerticesPerFace[0];\n"
                                    "float16 transfMatrix;\n"
                                    "float4 position = (float4) (vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],\n"
                                    "vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);\n"
                                    "for (int i = 0; i < 16; i++) {\n"
                                        "transfMatrix[i] = transfMatrices[instanceID*16+i];\n"
                                    "}\n"
                                    "float4 worldcoords = multMatVec(transfMatrix, position);\n"
                                    "float4 viewcoords = multMatVec(viewMatrix, worldcoords);\n"
                                    "float4 clipcoords = multMatVec(projMatrix, viewcoords);\n"
                                    "float4 ndcCoords = (float4) (clipcoords.x / clipcoords.w, clipcoords.y / clipcoords.w, clipcoords.z / clipcoords.w, 1 / clipcoords.w);\n"
                                    "position = multMatVec(viewportMatrix, ndcCoords);\n"
                                    "vPosX[tid] = position.x;\n"
                                    "vPosY[tid] = position.y;\n"
                                    "vPosZ[tid] = position.z;\n"
                                    "vPosW[tid] = position.w;\n"
                                "}\n"
                                "__kernel void geometryShader (__global float* vPosX, __global float* vPosY, __global float* vPosZ, __global float* vPosW,\n"
                                "                              __global float* outvPosX, __global float* outvPosY, __global float* outvPosZ, __global float* outvPosW,\n"
                                "                              __global unsigned int* indices,  __global unsigned int numIndices, __global unsigned int* baseIndices,\n"
                                "                              __global unsigned int* baseVertices, __global unsigned int* nbVerticesPerFace) {\n"
                                "   size_t tid = get_global_id(0);\n"
                                "   int instanceID = tid / nbVerticesPerFace[0];\n"
                                "   int offset = tid % nbVerticesPerFace[0];\n"
                                "   if (get_global_id(0) == numIndices-1) {\n"
                                "       if (nbVerticesPerFace[1] == 1) {\n"
                                "           float centerLineX=0, centerLineY=0, centerLineZ=0, centerLineW=0;\n"
                                "           float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],\n"
                                "           vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);\n"
                                "           float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],\n"
                                "           vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);\n"
                                "           centerLineX = (v1.x + v2.x) * 0.5;\n"
                                "           centerLineY = (v1.y + v2.y) * 0.5;\n"
                                "           centerLineZ = (v1.z + v2.z) * 0.5;\n"
                                "           centerLineW = (v1.w + v2.w) * 0.5;\n"
                                "           outvPosX[tid*2+1] = centerLineX;\n"
                                "           outvPosY[tid*2+1] = centerLineY;\n"
                                "           outvPosZ[tid*2+1] = centerLineZ;\n"
                                "           outvPosW[tid*2+1] = centerLineW;\n"
                                "       } else {\n"
                                "           float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],\n"
                                "           vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);\n"
                                "           outvPosX[tid*2] = v.x;\n"
                                "           outvPosY[tid*2] = v.y;\n"
                                "           outvPosZ[tid*2] = v.z;\n"
                                "           outvPosW[tid*2] = v.w;\n"
                                "       }\n"
                                "    } else {\n"
                                "       tid2 = tid + 1;\n"
                                "       int instanceID2 = tid2 / nbVerticesPerFace[0];\n"
                                "       int offset2 = tid2 % nbVerticesPerFace[0];\n"
                                "       float centerLineX=0, centerLineY=0, centerLineZ=0, centerLineW=0;\n"
                                "       float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],\n"
                                "       vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);\n"
                                "       float4 v2(vPosX[baseVertices[instanceID2]+indices[baseIndices[instanceID2]+offset2]], vPosY[baseVertices[instanceID2]+indices[baseIndices[instanceID2]+offset2]],\n"
                                "       vPosZ[baseVertices[instanceID2]	+ indices[baseIndices[instanceID2]+offset2],vPosW[baseVertices[instanceID2]+indices[baseIndices[instanceID2]+offset2]]);\n"
                                "       centerLineX = (v1.x + v2.x) * 0.5;\n"
                                "       centerLineY = (v1.y + v2.y) * 0.5;\n"
                                "       centerLineZ = (v1.z + v2.z) * 0.5;\n"
                                "       centerLineW = (v1.w + v2.w) * 0.5;\n"
                                "       outvPosX[tid*2] = v1.x;\n"
                                "       outvPosY[tid*2] = v1.y;\n"
                                "       outvPosZ[tid*2] = v1.z;\n"
                                "       outvPosW[tid*2] = v1.w;\n"
                                "       outvPosX[tid*2+1] = centerLineX;\n"
                                "       outvPosY[tid*2+1] = centerLineY;\n"
                                "       outvPosZ[tid*2+1] = centerLineZ;\n"
                                "       outvPosW[tid*2+1] = centerLineW;\n"
                                "   }\n"
                                "}\n"
                                "__kernel void tesslationShader(__global float* vPosX, __global float* vPosY, __global float* vPosZ, __global float* vPosW,\n"
                                "                               __global unsigned int* nbVerticesPerFaces, __global unsigned float* centersX, __global unsigned float* centersY,\n"
                                "                               __global unsigned float* centersZ, __global unsigned float* centersW) {\n"
                                "   size_t tid = get_global_id(0);\n"
                                "   float centerX=0, centerY=0, centerZ=0, centerW = 0;\n"
                                "   for (unsigned int i = 0; i < nbVerticesPerFace[2]; i++) {\n"
                                "        centerX += vPosX[tid*nbVerticesPerFace[2]+i];\n"
                                "        centerY += vPosY[tid*nbVerticesPerFace[2]+i];\n"
                                "        centerZ += vPosZ[tid*nbVerticesPerFace[2]+i];\n"
                                "        centerW += vPosW[tid*nbVerticesPerFace[2]+i];\n"
                                "   }\n"
                                "   centerX = centerX / nbVerticesPerFace[2];\n"
                                "   centerY = centerY / nbVerticesPerFace[2];\n"
                                "   centerZ = centerZ / nbVerticesPerFace[2];\n"
                                "   centerW = centerW / nbVerticesPerFace[2];\n"
                                "   centersX[tid] = centerX;\n"
                                "   centersY[tid] = centerY;\n"
                                "   centersZ[tid] = centerZ;\n"
                                "   centersW[tid] = centerW;\n"
                                "}";

Voici ce que j'ai dans mon fichier .log :

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
 
"/tmp/OCL9227T1.cl", line 2: warning: global variable declaration is corrected
          by the compiler to have addrSpace constant
  const int stepXSize = 4;
            ^
 
"/tmp/OCL9227T1.cl", line 3: warning: global variable declaration is corrected
          by the compiler to have addrSpace constant
  const int stepYSize = 4;
            ^
 
"/tmp/OCL9227T1.cl", line 10: error: vector subscript not support
  float elementA = matA[y * 4 + k];
                        ^
 
"/tmp/OCL9227T1.cl", line 11: error: vector subscript not support
  float elementB = matB[k * 4 + x];
                        ^
 
"/tmp/OCL9227T1.cl", line 14: error: vector subscript not support
  matC[y * 4 + x] = value;
       ^
 
"/tmp/OCL9227T1.cl", line 17: warning: variable "matC" is used before its
          value is set
  return matC;
         ^
 
"/tmp/OCL9227T1.cl", line 22: error: vector subscript not support
  result[i] = vecA[i] + vecB[i];
         ^
 
"/tmp/OCL9227T1.cl", line 22: error: vector subscript not support
  result[i] = vecA[i] + vecB[i];
                   ^
 
"/tmp/OCL9227T1.cl", line 22: error: vector subscript not support
  result[i] = vecA[i] + vecB[i];
                             ^
 
"/tmp/OCL9227T1.cl", line 24: warning: variable "result" is used before its
          value is set
  return result;
         ^
 
"/tmp/OCL9227T1.cl", line 29: error: vector subscript not support
  result[i] = vecA[i] * vecB[i];
         ^
 
"/tmp/OCL9227T1.cl", line 29: error: expression must have pointer-to-object
          type
  result[i] = vecA[i] * vecB[i];
              ^
 
"/tmp/OCL9227T1.cl", line 29: error: expression must have pointer-to-object
          type
  result[i] = vecA[i] * vecB[i];
                        ^
 
"/tmp/OCL9227T1.cl", line 31: warning: variable "result" is used before its
          value is set
  return result;
         ^
 
"/tmp/OCL9227T1.cl", line 38: error: vector subscript not support
  value += vecB[j] * matA[i][j];
                ^
 
"/tmp/OCL9227T1.cl", line 38: error: vector subscript not support
  value += vecB[j] * matA[i][j];
                          ^
 
"/tmp/OCL9227T1.cl", line 40: error: vector subscript not support
  vecC[i] = value;
       ^
 
"/tmp/OCL9227T1.cl", line 42: warning: variable "vecC" is used before its
          value is set
  return vecC;
         ^
 
"/tmp/OCL9227T1.cl", line 46: error: expected a ";"
  for (int i = 0; i < 4; ++i) {
  ^
 
"/tmp/OCL9227T1.cl", line 51: warning: parsing restarts here after previous
          syntax error
  return matT;
             ^
 
"/tmp/OCL9227T1.cl", line 52: warning: missing return statement at end of
          non-void function "transpose"
  }
  ^
 
"/tmp/OCL9227T1.cl", line 45: warning: variable "matT" was declared but never
          referenced
  float16 matT
          ^
 
"/tmp/OCL9227T1.cl", line 54: error: vector subscript not support
  return mat[0] * mat[2] - mat[1] * mat[3];
             ^
 
"/tmp/OCL9227T1.cl", line 54: error: vector subscript not support
  return mat[0] * mat[2] - mat[1] * mat[3];
                      ^
 
"/tmp/OCL9227T1.cl", line 54: error: vector subscript not support
  return mat[0] * mat[2] - mat[1] * mat[3];
                               ^
 
"/tmp/OCL9227T1.cl", line 54: error: vector subscript not support
  return mat[0] * mat[2] - mat[1] * mat[3];
                                        ^
 
"/tmp/OCL9227T1.cl", line 56: error: declaration is incompatible with
          overloaded function "min"
  float min (float3 vec) {
        ^
 
"/tmp/OCL9227T1.cl", line 59: error: vector subscript not support
  if (vec[i] < cmin)
          ^
 
"/tmp/OCL9227T1.cl", line 60: error: vector subscript not support
  cmin = vec[i];
             ^
 
"/tmp/OCL9227T1.cl", line 64: error: declaration is incompatible with
          overloaded function "max"
  float max (float3 vec) {
        ^
 
"/tmp/OCL9227T1.cl", line 67: error: vector subscript not support
  if (vec[i] > cmax)
          ^
 
"/tmp/OCL9227T1.cl", line 68: error: vector subscript not support
  cmax = vec[i];
             ^
 
"/tmp/OCL9227T1.cl", line 80: error: type name is not allowed
  float4 x = addVec(float4 (origin.x, origin.x, origin.x, origin.x), float4(0,1,2,3));
                    ^
 
"/tmp/OCL9227T1.cl", line 80: error: type name is not allowed
  float4 x = addVec(float4 (origin.x, origin.x, origin.x, origin.x), float4(0,1,2,3));
                                                                     ^
 
"/tmp/OCL9227T1.cl", line 81: error: type name is not allowed
  float4 y = addVec(float4 (origin.y, origin.y, origin.y, origin.y), float4(0,1,2,3));
                    ^
 
"/tmp/OCL9227T1.cl", line 81: error: type name is not allowed
  float4 y = addVec(float4 (origin.y, origin.y, origin.y, origin.y), float4(0,1,2,3));
                                                                     ^
 
"/tmp/OCL9227T1.cl", line 82: error: type name is not allowed
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                               ^
 
"/tmp/OCL9227T1.cl", line 82: error: argument of type "float4" is incompatible
          with parameter of type "float"
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                                                   ^
 
"/tmp/OCL9227T1.cl", line 82: error: type name is not allowed
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                                                               ^
 
"/tmp/OCL9227T1.cl", line 82: error: mixed vector-scalar operation not allowed
          unless up-convertable(scalar-type=>vector-element-type)
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                                                                                  ^
 
"/tmp/OCL9227T1.cl", line 82: error: too few arguments in function call
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                                                                                   ^
 
"/tmp/OCL9227T1.cl", line 82: error: type name is not allowed
  return addVec(addVec(multVec(float4(a, a, a, a), x), multVec(float4(b, b, b, b)*y)), float4(c, c, c, c));
                                                                                       ^
 
"/tmp/OCL9227T1.cl", line 75: warning: parameter "oneStepX" was set but never
          used
  float4 initEdge (const float2 v0, const float2 v1, const float2 origin, float4 oneStepX, float4 oneStepY) {
                                                                                 ^
 
"/tmp/OCL9227T1.cl", line 75: warning: parameter "oneStepY" was set but never
          used
  float4 initEdge (const float2 v0, const float2 v1, const float2 origin, float4 oneStepX, float4 oneStepY) {
                                                                                                  ^
 
"/tmp/OCL9227T1.cl", line 84: error: a parameter cannot be allocated in a
          named address space
  __global unsigned int* indices,  __global unsigned int numIndices, __global unsigned int* baseIndices,
                                   ^
 
"/tmp/OCL9227T1.cl", line 86: error: a parameter cannot be allocated in a
          named address space
  __global float* transfMatrices, __global float16 projMatrix, __global float16 viewMatrix,
                                  ^
 
"/tmp/OCL9227T1.cl", line 86: error: a parameter cannot be allocated in a
          named address space
  __global float* transfMatrices, __global float16 projMatrix, __global float16 viewMatrix,
                                                               ^
 
"/tmp/OCL9227T1.cl", line 87: error: a parameter cannot be allocated in a
          named address space
  __global float16 viewportMatrix) {
  ^
 
"/tmp/OCL9227T1.cl", line 95: error: vector subscript not support
  transfMatrix[i] = transfMatrices[instanceID*16+i];
               ^
 
"/tmp/OCL9227T1.cl", line 97: warning: variable "transfMatrix" is used before
          its value is set
  float4 worldcoords = multMatVec(transfMatrix, position);
                                  ^
 
"/tmp/OCL9227T1.cl", line 109: error: a parameter cannot be allocated in a
          named address space
                                __global unsigned int* indices,  __global unsigned int numIndices, __global unsigned int* baseIndices,
                                                                 ^
 
"/tmp/OCL9227T1.cl", line 117: error: parameter "vPosX" is not a type name
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                       ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                             ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                          ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                              ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                          ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                      ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                      ^
 
"/tmp/OCL9227T1.cl", line 117: error: parameter "vPosY" is not a type name
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                      ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                                   ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                                                       ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                                                                   ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                                                                               ^
 
"/tmp/OCL9227T1.cl", line 117: error: expression must have a constant value
             float4 v1(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                                                                               ^
 
"/tmp/OCL9227T1.cl", line 118: error: parameter "vPosZ" is not a type name
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
             ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                   ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                    ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                            ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                            ^
 
"/tmp/OCL9227T1.cl", line 118: error: parameter "vPosW" is not a type name
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                     ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                           ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                                        ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                                                            ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                                                                        ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                                                                                    ^
 
"/tmp/OCL9227T1.cl", line 118: error: expression must have a constant value
             vPosZ[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],vPosW[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]]);
                                                                                                                    ^
 
"/tmp/OCL9227T1.cl", line 119: error: parameter "vPosX" is not a type name
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                       ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                             ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                     ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                             ^
 
"/tmp/OCL9227T1.cl", line 119: error: expected a "]"
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                    ^
 
"/tmp/OCL9227T1.cl", line 119: error: parameter "vPosY" is not a type name
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                      ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                            ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                                                    ^
 
"/tmp/OCL9227T1.cl", line 119: error: expression must have a constant value
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                                            ^
 
"/tmp/OCL9227T1.cl", line 119: error: expected a "]"
             float4 v2(vPosX[baseVertices[0]+indices[baseIndices[0]], vPosY[baseVertices[0]+indices[baseIndices[0]],
                                                                                                                   ^
 
"/tmp/OCL9227T1.cl", line 120: error: parameter "vPosZ" is not a type name
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
             ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                   ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	          ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	  ^
 
"/tmp/OCL9227T1.cl", line 120: error: expected a "]"
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                         ^
 
"/tmp/OCL9227T1.cl", line 120: error: parameter "vPosW" is not a type name
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                          ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                                ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                                                        ^
 
"/tmp/OCL9227T1.cl", line 120: error: expression must have a constant value
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                                                ^
 
"/tmp/OCL9227T1.cl", line 120: error: expected a "]"
             vPosZ[baseVertices[0]	+ indices[baseIndices[0]],vPosW[baseVertices[0]+indices[baseIndices[0]]);
                                  	                                                                       ^
 
"/tmp/OCL9227T1.cl", line 121: error: expression must have struct or union type
             centerLineX = (v1.x + v2.x) * 0.5;
                            ^
 
"/tmp/OCL9227T1.cl", line 121: error: expression must have struct or union type
             centerLineX = (v1.x + v2.x) * 0.5;
                                   ^
 
"/tmp/OCL9227T1.cl", line 122: error: expression must have struct or union type
             centerLineY = (v1.y + v2.y) * 0.5;
                            ^
 
"/tmp/OCL9227T1.cl", line 122: error: expression must have struct or union type
             centerLineY = (v1.y + v2.y) * 0.5;
                                   ^
 
"/tmp/OCL9227T1.cl", line 123: error: expression must have struct or union type
             centerLineZ = (v1.z + v2.z) * 0.5;
                            ^
 
"/tmp/OCL9227T1.cl", line 123: error: expression must have struct or union type
             centerLineZ = (v1.z + v2.z) * 0.5;
                                   ^
 
"/tmp/OCL9227T1.cl", line 124: error: expression must have struct or union type
             centerLineW = (v1.w + v2.w) * 0.5;
                            ^
 
"/tmp/OCL9227T1.cl", line 124: error: expression must have struct or union type
             centerLineW = (v1.w + v2.w) * 0.5;
                                   ^
 
"/tmp/OCL9227T1.cl", line 130: error: parameter "vPosX" is not a type name
             float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                      ^
 
"/tmp/OCL9227T1.cl", line 130: error: expression must have a constant value
             float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                            ^
 
"/tmp/OCL9227T1.cl", line 130: error: expression must have a constant value
             float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                         ^
 
"/tmp/OCL9227T1.cl", line 130: error: expression must have a constant value
             float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                             ^
 
"/tmp/OCL9227T1.cl", line 130: error: expression must have a constant value
             float4 v(vPosX[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]], vPosY[baseVertices[instanceID]+indices[baseIndices[instanceID]+offset]],
                                                                         ^
 
Error limit reached.
100 errors detected in the compilation of "/tmp/OCL9227T1.cl".
Compilation terminated.
 
Frontend phase failed compilation.
Merci d'avance pour votre aide.