Discussion :

[Laurent7601]

Salut! J'essaie de rendre des ombres en 3D mais je me retrouve avec plusieurs soucis.
Le premier soucis est que si il y a quelque chose devant l'ombre comme une pente par exemple, je dois la cacher, pour faire cela j'ai créer une depth buffer text et j'ai comparé le z avec le z de l'ombre pour voir si il n'y a pas d'objets devant. Mais ça pose un second soucis, en effet, si l'ombre s'affiche sur une pente par exemple, et que le z de la pente est devant le z de l'ombre, l'ombre est cachée hors qu'elle doit s'afficher sur la pente, pour régler ce second problème, j'utilise une matrice pour transformer l'ombre pour que l'ombre soit inclinée avec la pente. Mais le rendu n'est pas celui auxquel je m'attendais, j'ai des drôles d'effets de scintillement et des points noirs à certains endroit.

Voici mes shaders :

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
 
const std::string buildDepthBufferVertexShaderNormal = R"(#version 460
                                                                              layout (location = 0) in vec3 position;
                                                                              layout (location = 1) in vec4 color;
                                                                              layout (location = 2) in vec2 texCoords;
                                                                              layout (location = 3) in vec3 normals;
                                                                              layout (location = 4) in uint textureIndex;
                                                                              layout (location = 6) in uint l;
                                                                              uniform mat4 projectionMatrix;
                                                                              uniform mat4 viewMatrix;
                                                                              uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                              out vec2 fTexCoords;
                                                                              out vec4 frontColor;
                                                                              out uint texIndex;
                                                                              out uint layer;
                                                                              void main() {
                                                                                  gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.f);
                                                                                  fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                                  frontColor = color;
                                                                                  texIndex = textureIndex;
                                                                                  layer = l;
                                                                              }
                                                                              )";
                    const std::string buildDepthBufferVertexShader = R"(#version 460
                                                                        layout (location = 0) in vec3 position;
                                                                        layout (location = 1) in vec4 color;
                                                                        layout (location = 2) in vec2 texCoords;
                                                                        layout (location = 3) in vec3 normals;
                                                                        layout (location = 4) in mat4 worldMat;
                                                                        layout (location = 12) in uint textureIndex;
                                                                        layout (location = 14) in uint l;
                                                                        uniform mat4 projectionMatrix;
                                                                        uniform mat4 viewMatrix;
                                                                        uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                        out vec2 fTexCoords;
                                                                        out vec4 frontColor;
                                                                        out uint texIndex;
                                                                        out uint layer;
                                                                        void main() {
                                                                            gl_Position = projectionMatrix * viewMatrix * worldMat * vec4(position, 1.f);
                                                                            fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                            frontColor = color;
                                                                            texIndex = textureIndex;
                                                                            layer = l;
                                                                        }
                                                                     )";
                     const std::string buildDepthBufferFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
 
                                                                          layout(binding = 0, rgba32f) uniform image2D depthBuffer;
                                                                          layout (location = 0) out vec4 fColor;
 
                                                                          void main () {
                                                                              vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                              float z = gl_FragCoord.z;
                                                                              float l = layer;
                                                                              vec4 depth = imageLoad(depthBuffer,ivec2(gl_FragCoord.xy));
                                                                              if (l > depth.y || l == depth.y && z > depth.z) {
                                                                                fColor = vec4(0, l, z, texel.a);
                                                                                imageStore(depthBuffer,ivec2(gl_FragCoord.xy),vec4(0,l,z,texel.a));
                                                                              } else {
                                                                                fColor = depth;
                                                                              }
                                                                          }
                                                                        )";
                     const std::string buildAlphaBufferFragmentShader = R"(#version 460
                                                                      #extension GL_ARB_bindless_texture : enable
                                                                      layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                        sampler2D textures[200];
                                                                      };
                                                                      layout(binding = 0, rgba32f) uniform image2D alphaBuffer;
                                                                      layout (location = 0) out vec4 fColor;
                                                                      uniform sampler2D depthBuffer;
                                                                      uniform sampler2D stencilBuffer;
                                                                      uniform vec3 resolution;
                                                                      uniform mat4 lviewMatrix;
                                                                      uniform mat4 lprojectionMatrix;
                                                                      in vec4 frontColor;
                                                                      in vec2 fTexCoords;
                                                                      in flat uint texIndex;
                                                                      in flat uint layer;
                                                                      in vec4 shadowCoords;
                                                                      void main() {
                                                                          vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                          float current_alpha = texel.a;
                                                                          vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                          vec4 depth = texture2D (depthBuffer, position);
                                                                          vec4 alpha = imageLoad(alphaBuffer,ivec2(gl_FragCoord.xy));
                                                                          vec4 stencil = texture2D (stencilBuffer, shadowCoords.xy);
                                                                          float l = layer;
                                                                          float z = gl_FragCoord.z;
                                                                          if (/*l > stencil.y || l == stencil.y &&*/ stencil.z < shadowCoords.z && depth.z > z && current_alpha > alpha.a) {
                                                                              imageStore(alphaBuffer,ivec2(gl_FragCoord.xy),vec4(0, l, z, current_alpha));
                                                                          } else {
                                                                              fColor = alpha;
                                                                          }
                                                                      }
                                                                      )";
                    /*const std::string buildShadowMapVertexShaderNormal = R"(#version 460
                                                                            layout (location = 0) in vec3 position;
                                                                            layout (location = 1) in vec4 color;
                                                                            layout (location = 2) in vec2 texCoords;
                                                                            layout (location = 3) in vec3 normals;
                                                                            uniform mat4 projectionMatrix;
                                                                            uniform mat4 viewMatrix;
                                                                            uniform mat4 textureMatrix;
                                                                            out vec2 fTexCoords;
                                                                            out vec4 frontColor;
                                                                            void main() {
                                                                                gl_Position = projectionMatrix * viewMatrix  * vec4(position, 1.f);
                                                                                fTexCoords = (textureMatrix * vec4(texCoords, 1.f, 1.f)).xy;
                                                                                frontColor = color;
                                                                            }
                                                                        )";
                    const std::string buildShadowMapVertexShader = R"(#version 460
                                                                      layout (location = 0) in vec3 position;
                                                                      layout (location = 1) in vec4 color;
                                                                      layout (location = 2) in vec2 texCoords;
                                                                      layout (location = 3) in vec3 normals;
                                                                      layout (location = 4) in mat4 worldMat;
                                                                      uniform mat4 projectionMatrix;
                                                                      uniform mat4 viewMatrix;
                                                                      uniform mat4 textureMatrix;
                                                                      out vec2 fTexCoords;
                                                                      out vec4 frontColor;
                                                                      void main() {
                                                                          gl_Position = projectionMatrix * viewMatrix  * worldMat * vec4(position, 1.f);
                                                                          fTexCoords = (textureMatrix * vec4(texCoords, 1.f, 1.f)).xy;
                                                                          frontColor = color;
                                                                      }
                                                                    )";*/
                    const std::string buildShadowMapFragmentShader = R"(#version 460
                                                                        #extension GL_ARB_bindless_texture : enable
                                                                        in vec4 frontColor;
                                                                        in vec2 fTexCoords;
 
                                                                        layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                            sampler2D textures[200];
                                                                        };
                                                                        in flat uint texIndex;
                                                                        in flat uint layer;
                                                                        layout(binding = 0, rgba32f) uniform image2D stencilBuffer;
                                                                        layout (location = 0) out vec4 fColor;
                                                                        void main() {
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
                                                                            float current_alpha = texel.a;
                                                                            vec4 alpha = imageLoad(stencilBuffer,ivec2(gl_FragCoord.xy));
                                                                            float l = layer;
                                                                            float z = gl_FragCoord.z;
                                                                            if (/*l > alpha.y || l == alpha.y &&*/ z > alpha.z) {
                                                                              fColor = vec4(0, l, z, current_alpha);
                                                                              imageStore(stencilBuffer,ivec2(gl_FragCoord.xy),vec4(0, l, z, current_alpha));
                                                                          } else {
                                                                              fColor = alpha;
                                                                          }
                                                                        }
                                                                    )";
                        const std::string perPixShadowVertexShader = R"(#version 460
                                                                   layout (location = 0) in vec3 position;
                                                                   layout (location = 1) in vec4 color;
                                                                   layout (location = 2) in vec2 texCoords;
                                                                   layout (location = 3) in vec3 normals;
                                                                   layout (location = 4) in mat4 worldMat;
                                                                   layout (location = 8) in mat4 shadowProjMat;
                                                                   layout (location = 12) in uint textureIndex;
                                                                   layout (location = 14) in uint l;
                                                                   uniform mat4 projectionMatrix;
                                                                   uniform mat4 viewMatrix;
                                                                   uniform mat4 lviewMatrix;
                                                                   uniform mat4 lprojectionMatrix;
                                                                   uniform mat4 depthBiasMatrix;
                                                                   uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                   out vec4 shadowCoords;
                                                                   out vec4 frontColor;
                                                                   out vec2 fTexCoords;
                                                                   out uint texIndex;
                                                                   out uint layer;
                                                                   void main() {
                                                                       gl_Position = projectionMatrix * viewMatrix * shadowProjMat * worldMat * vec4(position, 1.f);
                                                                       fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                       frontColor = color;
                                                                       shadowCoords = depthBiasMatrix * lviewMatrix * lprojectionMatrix *  vec4(gl_Position.xyz, 1);
                                                                       texIndex = textureIndex;
                                                                       layer = l;
                                                                   }
                                                                  )";
                        const std::string perPixShadowNormalVertexShader = R"(#version 460
                                                                   layout (location = 0) in vec3 position;
                                                                   layout (location = 1) in vec4 color;
                                                                   layout (location = 2) in vec2 texCoords;
                                                                   layout (location = 3) in vec3 normals;
                                                                   layout (location = 4) in uint textureIndex;
                                                                   layout (location = 6) in uint l;
                                                                   uniform mat4 projectionMatrix;
                                                                   uniform mat4 viewMatrix;
                                                                   uniform mat4 lviewMatrix;
                                                                   uniform mat4 lprojectionMatrix;
                                                                   uniform mat4 depthBiasMatrix;
                                                                   uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                   out vec4 shadowCoords;
                                                                   out vec4 frontColor;
                                                                   out vec2 fTexCoords;
                                                                   out uint texIndex;
                                                                   out uint layer;
                                                                   void main() {
                                                                       gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.f);
                                                                       fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                       frontColor = color;
                                                                       shadowCoords = depthBiasMatrix * lviewMatrix * lprojectionMatrix * vec4(gl_Position.xyz, 1);
                                                                       texIndex = textureIndex;
                                                                       layer = l;
                                                                   }
                                                                  )";
                        const std::string perPixShadowFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 shadowCoords;
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          uniform sampler2D texture;
                                                                          uniform sampler2D stencilBuffer;
                                                                          uniform sampler2D depthBuffer;
                                                                          uniform sampler2D alphaBuffer;
                                                                          uniform float haveTexture;
                                                                          uniform vec3 resolution;
                                                                          layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
                                                                          layout (location = 0) out vec4 fColor;
                                                                          void main() {
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture2D(depthBuffer, position);
                                                                            vec4 alpha = texture2D(alphaBuffer, position);
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
 
                                                                            float color = texel.a;
                                                                            vec4 stencil = texture2D (stencilBuffer, shadowCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            vec4 visibility;
                                                                            uint l = layer;
                                                                            if (/*l > stencil.y || l == stencil.y &&*/ stencil.z < shadowCoords.z) {
                                                                                if (depth.z > z) {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, alpha.a);
                                                                                } else {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }
                                                                            fColor = visibility;
                                                                          }
                                                                          )";
                        if (!depthGenShader.loadFromMemory(buildDepthBufferVertexShader, buildDepthBufferFragmentShader))  {
                            throw core::Erreur(52, "Error, failed to load build depth buffer shader", 3);
                        }
                        if (!depthGenNormalShader.loadFromMemory(buildDepthBufferVertexShaderNormal, buildDepthBufferFragmentShader)) {
                            throw core::Erreur(51, "Error, failed to load build depth buffer normal shader", 3);
                        }
                        if (!buildShadowMapShader.loadFromMemory(buildDepthBufferVertexShader, buildShadowMapFragmentShader)) {
                            throw core::Erreur(53, "Error, failed to load build shadow map shader", 3);
                        }
                        if (!buildShadowMapNormalShader.loadFromMemory(buildDepthBufferVertexShaderNormal, buildShadowMapFragmentShader)) {
                            throw core::Erreur(50, "Error, failed to load build shadow map normal shader", 3);
                        }
                        if (!perPixShadowShader.loadFromMemory(perPixShadowVertexShader, perPixShadowFragmentShader)) {
                            throw core::Erreur(54, "Error, failed to load per pix shadow map shader", 3);
                        }
                        if (!perPixShadowShaderNormal.loadFromMemory(perPixShadowNormalVertexShader, perPixShadowFragmentShader)) {
                            throw core::Erreur(54, "Error, failed to load per pix normal shadow map shader", 3);
                        }
                        if (!sBuildAlphaBufferShader.loadFromMemory(perPixShadowVertexShader,buildAlphaBufferFragmentShader)) {
                            throw core::Erreur(60, "Error, failed to load build alpha buffer shader", 3);
                        }
                        if (!sBuildAlphaBufferNormalShader.loadFromMemory(perPixShadowNormalVertexShader,buildAlphaBufferFragmentShader)) {
                            throw core::Erreur(60, "Error, failed to load build alpha normal buffer shader", 3);
                        }
                        depthGenShader.setParameter("texture", Shader::CurrentTexture);
                        buildShadowMapShader.setParameter("texture", Shader::CurrentTexture);
                        depthGenNormalShader.setParameter("texture", Shader::CurrentTexture);
                        buildShadowMapNormalShader.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        perPixShadowShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        perPixShadowShader.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        perPixShadowShader.setParameter("alphaBuffer", alphaBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("depthBuffer", depthBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShaderNormal.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        perPixShadowShaderNormal.setParameter("alphaBuffer", alphaBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("texture", Shader::CurrentTexture);
                        sBuildAlphaBufferShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        sBuildAlphaBufferNormalShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        sBuildAlphaBufferNormalShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        sBuildAlphaBufferNormalShader.setParameter("texture", Shader::CurrentTexture);
                        sBuildAlphaBufferNormalShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);

buildDepthBufferVertexShaderNormal ne fait rien d'autre que de calculer la position du sommet avec les matrices de transformation et de vue, je passe l'index de la texture pour le bindless texturing et un layer car je peux vouloir afficher des entités sur plusieurs couches c'est comme un second z si vous voulez.

buildDepthBufferVertexShader fait la même chose mais pour l'instanced rendering.

buildDepthBufferFragmentShader se charge de créer la depthTexture je vérifie si la couche et le z sont plus grand, si oui, je stocke les valeurs dans la depth texture.

buildAlphaBufferFragmentShader vérifie si le fragment est dans l'ombre et si il y a quelque chose devant l'ombre et stocke la valeur alpha du fragment pour plus tard.

buildShadowMapFragmentShader se charge de calculer les distances entre la lumière et les fragments des objets.

perPixShadowNormalVertexShader calcule la position de mes ombres par rapport à la caméra et par rapport à la lumière.

perPixShadowVertexShader fait la même chose avec l'instanced rendering.

perPixShadowFragmentShader effectue le rendu final c'est à dire :

-test si le pixel est dans l'ombre.
-si oui test si il y a quelque chose devant l'ombre, si oui, on cache l'ombre en fonction de l'alpha de ce qui se trouve devant l'ombre, sinon, on affiche l'ombre en fonction de l'alpha de l'objet.

Voilà c'est tout pour les shaders mais le rendu est bizarre j'ai des pixels qui clignotent et je n'ai pas l'impression que la coordonnée z est bonne et que l'ombre est vraiment affichée ou cachée suivant ce qu'il y a devant.

Voyer plutôt :

J'ai des pixels qui deviennent blanc puis noir et lorsque je vais derrière la pente ça affiche toujours l'ombre de mon modèle 3D.
Par contre en 2D je n'ai aucun problème.
Et je vois pas du tout comment gérer les ombres en 3D surtout avec une heightmap...

EDIT : j'ai modifier mon shader :

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
const std::string perPixShadowFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 shadowCoords;
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          uniform sampler2D texture;
                                                                          uniform sampler2D stencilBuffer;
                                                                          uniform sampler2D depthBuffer;
                                                                          uniform sampler2D alphaBuffer;
                                                                          uniform float haveTexture;
                                                                          uniform vec3 resolution;
                                                                          layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
                                                                          layout (location = 0) out vec4 fColor;
                                                                          void main() {
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture2D(depthBuffer, position);
                                                                            vec4 alpha = texture2D(alphaBuffer, position);
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
 
                                                                            float color = texel.a;
                                                                            vec4 stencil = texture2D (stencilBuffer, shadowCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            vec4 visibility;
                                                                            uint l = layer;
                                                                            if (/*l > stencil.y || l == stencil.y &&*/ stencil.z < shadowCoords.z) {
                                                                                if (depth.z > z) {
                                                                                    visibility = vec4 (1, 1, 1, alpha.a);
                                                                                } else {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }
                                                                            fColor = visibility;
                                                                          }
                                                                          )";

Mais le rendu reste étrange :

EDIT 2 : j'ai corriger quelques erreur dans ma classe ShadowRenderComponent et ça va un petit peu mieux mais j'ai toujours des scintillements pour les ombres du sol mais ce que je ne comprend pas c'est au niveau du sol j'ai toujours une ligne qui vient couper le dessin de l'ombre (ou de la lumière) hors que il n'y a rien qui s'affiche devant l'ombre ou la lumière.

EDIT 3 : Rien à faire la coordonnée z n'est pas bonne et je ne comprend pas pourquoi.

[Laurent7601]

J'ai imprimé les positions en z pour le premier fragment :

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
 
const std::string perPixShadowFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 shadowCoords;
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          uniform sampler2D texture;
                                                                          uniform sampler2D stencilBuffer;
                                                                          uniform sampler2D depthBuffer;
                                                                          uniform sampler2D alphaBuffer;
                                                                          uniform float haveTexture;
                                                                          uniform vec3 resolution;
                                                                          layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
                                                                          layout (location = 0) out vec4 fColor;
                                                                          layout(rgba32f, binding = 0) uniform image2D img_output;
                                                                          layout(binding = 0, offset = 0) uniform atomic_uint nextNodeCounter;
 
                                                                         /*Functions to debug, draw numbers to the image,
                                                                          draw a vertical ligne*/
                                                                          void drawVLine (ivec2 position, int width, int nbPixels, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y < startY + nbPixels) {
                                                                                 while (position.x < startX + width) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y++;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          /*Draw an horizontal line*/
                                                                          void drawHLine (ivec2 position, int height, int nbPixels, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y > startY - height) {
                                                                                 while (position.x < startX + nbPixels) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y--;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          /*Draw digits.*/
                                                                          void drawDigit (ivec2 position, int nbPixels, vec4 color, uint digit) {
                                                                              int digitSize = nbPixels * 10;
                                                                              if (digit == 0) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(position, digitSize, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 1) {
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                              } else if (digit == 2) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 3) {
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 4) {
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 5) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 6) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(position, digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 7) {
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                              } else if (digit == 8) {
                                                                                  drawHLine(position, digitSize, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 9) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              }
                                                                          }
                                                                          void drawSquare(ivec2 position, int size, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y > startY - size) {
                                                                                 while (position.x < startX + size) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y--;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          void drawPunt(ivec2 position, int nbPixels, vec4 color) {
                                                                              int puntSize = nbPixels * 2;
                                                                              drawSquare(position, puntSize, color);
                                                                          })" \
                                                                          R"(ivec2 print (ivec2 position, int nbPixels, vec4 color, double number) {
                                                                              int digitSize = nbPixels * 10;
                                                                              int digitSpacing = nbPixels * 6;
                                                                              if (number < 0) {
                                                                                 number = -number;
                                                                                 drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                 position.x += digitSpacing;
                                                                              }
                                                                              int pe = int(number);
                                                                              int n = 0;
                                                                              uint rpe[10];
                                                                              do {
                                                                                 uint digit = pe % 10;
                                                                                 pe /= 10;
                                                                                 if (n < 10) {
                                                                                    rpe[n] = digit;
                                                                                 }
                                                                                 n++;
                                                                              } while (pe != 0);
                                                                              if (n >= 10)
                                                                                n = 9;
                                                                              //drawDigit(position, nbPixels, color,0);
                                                                              for (int i = n-1; i >= 0; i--) {
                                                                                 drawDigit(position, nbPixels, color, rpe[i]);
                                                                                 //drawDigit(position, nbPixels, color,n-i-1);
                                                                                 position.x += digitSpacing;
                                                                              }
                                                                              double rest = fract(number);
                                                                              if (rest > 0) {
                                                                                  drawPunt(position, nbPixels, color);
                                                                                  position.x += digitSpacing;
                                                                                  do {
                                                                                     rest *= 10;
                                                                                     int digit = int(rest);
                                                                                     rest -= digit;
                                                                                     drawDigit(position, nbPixels, color, digit);
                                                                                     position.x += digitSpacing;
                                                                                  } while (rest != 0);
                                                                              }
                                                                              return position;
                                                                          }
                                                                          ivec2 print (ivec2 position, int nbPixels, vec4 color, mat4 matrix) {
                                                                              int numberSpacing = 10;
                                                                              for (uint i = 0; i < 4; i++) {
                                                                                 for (uint j = 0; j < 4; j++) {
                                                                                    position = print(position, nbPixels, color, matrix[i][j]);
                                                                                    position.x += numberSpacing;
                                                                                 }
                                                                              }
                                                                              return position;
                                                                          }
                                                                          ivec2 print (ivec2 position, int nbPixels, vec4 color, vec4 vector) {
                                                                              int numberSpacing = 10;
                                                                              for (uint i = 0; i < 4; i++) {
                                                                                position = print(position, nbPixels, color, vector[i]);
                                                                                position.x += numberSpacing;
                                                                              }
                                                                              return position;
                                                                          }
                                                                        void main() {
                                                                            uint fragmentIdx = atomicCounterIncrement(nextNodeCounter);
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture2D(depthBuffer, position);
                                                                            vec4 alpha = texture2D(alphaBuffer, position);
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
 
                                                                            float color = texel.a;
                                                                            vec4 stencil = texture2D (stencilBuffer, shadowCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            vec4 visibility;
                                                                            uint l = layer;
                                                                            if (l > stencil.y || l == stencil.y && stencil.z < shadowCoords.z) {
                                                                                if (depth.z > z) {
                                                                                    visibility = vec4 (1, 1, 1, alpha.a);
                                                                                } else {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }
                                                                            if (fragmentIdx == 0)
                                                                                print(ivec2(200, 100), 1, vec4(1, 0, 0, 1), vec4(0, depth.z, z, 1));
                                                                            fColor = visibility;
                                                                          }
                                                                          )";

Et en effet, elles ne sont pas bonnes, déjà ce qui est bizarre c'est que, sans bouger la vue, j'ai les positions en z qui changent à chaque frame, ce qui explique les effets de clignotement que j'ai eu, et la position en z n'est pas bonne.
Le problème vient peut être de ma matrice de projection :

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
void ProjMatrix::setGlPerspectiveMatrix (double l, double r, double b, double t, double n, double f) {
            matrix4f.m11 = (2 * n) / (r - l);
            matrix4f.m12 = 0;
            matrix4f.m13 = (r + l) / (r - l);
            matrix4f.m14 = 0;
            matrix4f.m21 = 0;
            matrix4f.m22 = (2 * n) / (t - b);
            matrix4f.m23 = (t + b) / (t - b);
            matrix4f.m24 = 0;
            matrix4f.m31 = 0;
            matrix4f.m32 = 0;
            matrix4f.m33 = ((f + n) / (f - n));
            matrix4f.m34 = (2 * f * n) / (f - n);
            matrix4f.m41 = 0;
            matrix4f.m42 = 0;
            matrix4f.m43 = -1;
            matrix4f.m44 = 0;
            this->l = l;
            this->r = r;
            this->b = b;
            this->t = t;
            this->n = n;
            this->f = f;
            invMatrix4f = matrix4f.inverse();
        }

J'ai fait en sorte que le z est plus grand pour les fragments les plus proche, je ne sais pas si j'inverse le sens de z si ça va corriger le problème mais du coup je dois modifier le code de tout mes shaders sans savoir si ça corrigera le problème.

EDIT : j'ai changé la valeur du zNear et ça va mieux par contre j'ai toujours ce problème de pixels qui scintille je ne sais pas pourquoi la valeur z de mes pixels change à chaque frame.

EDIT2 : Lorsque je passe mes variables uniform à mon shader, les valeurs changent à chaque frame (les matrices) du coup la valeur de z de mes fragments est différente à chaque frame et les valeurs de z de certains de mes fragment n'est pas bonne elles sont plus élevées que celles de ma depthTexture hors que elles sont derrière.

[Laurent7601]

Salut!

J'ai essayé plusieurs choses :

-J'ai changé mes matrices de vue et de projection pour avoir quelque chose comme glm.
-J'ai essayé de faire quelque chose de similaire à cette technique : https://learnopengl.com/Advanced-Lig...Shadow-Mapping

Mais le résultat est bizarre certains pixels de l'ombre s'affiche et d'autres pas :



Pourtant, j'ai fait comme dans le tutoriel c'est à dire.

-J'ai mit la vue à la position de la lumière et je regarde vers la position de la caméra pour être sûr que mes objets visible avec la caméra soient visible avec la lumière.

-Je rend les objets sur ma shadowMap en coordonnées lumière.

-Je dessine les objets et je vérifie si il n'y a pas un obstacle entre l'objet et la lumière en comparent les z de la shadowMap et du fragment en coordonnées lumière.

Mon renderer ressemble donc à 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
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
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
#include "../../../include/odfaeg/Graphics/shadowRenderComponent.hpp"
#ifndef VULKAN
#include <SFML/OpenGL.hpp>
#include "glCheck.h"
#endif
#include <memory.h>
using namespace sf;
using namespace std;
namespace odfaeg {
    namespace graphic {
        #ifdef VULKAN
        #else
            ShadowRenderComponent::ShadowRenderComponent (RenderWindow& window, int layer, std::string expression,window::ContextSettings settings) :
            HeavyComponent(window, math::Vec3f(window.getView().getPosition().x, window.getView().getPosition().y, layer),
                          math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0),
                          math::Vec3f(window.getView().getSize().x + window.getView().getSize().x * 0.5f, window.getView().getPosition().y + window.getView().getSize().y * 0.5f, layer)),
            view(window.getView()),
            quad(math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, window.getSize().y * 0.5f)),
            expression(expression) {
            update = false;
            quad.move(math::Vec3f(-window.getView().getSize().x * 0.5f, -window.getView().getSize().y * 0.5f, 0));
            sf::Vector3i resolution ((int) window.getSize().x, (int) window.getSize().y, window.getView().getSize().z);
 
            depthBuffer.create(resolution.x, resolution.y, settings);
 
            depthBufferTile = Sprite(depthBuffer.getTexture(), math::Vec3f(0, 0, 0), math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0), IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
 
            glCheck(glGenTextures(1, &depthTex));
            glCheck(glBindTexture(GL_TEXTURE_2D, depthTex));
            glCheck(glTexStorage2D(GL_TEXTURE_2D,1,GL_RGBA32F,window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glBindImageTexture(0, depthTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F));
            glCheck(glBindTexture(GL_TEXTURE_2D, 0));
            std::vector<GLfloat> depthClearBuf(window.getView().getSize().x*window.getView().getSize().y*4, 0);
            glCheck(glGenBuffers(1, &clearBuf));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf));
            glCheck(glBufferData(GL_PIXEL_UNPACK_BUFFER, depthClearBuf.size() * sizeof(GLfloat),
            &depthClearBuf[0], GL_STATIC_COPY));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
 
            stencilBuffer.create(resolution.x, resolution.y,settings);
            stencilBufferTile = Sprite(stencilBuffer.getTexture(), math::Vec3f(0, 0, 0), math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0), IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glGenTextures(1, &stencilTex));
            glCheck(glBindTexture(GL_TEXTURE_2D, stencilTex));
            glCheck(glTexStorage2D(GL_TEXTURE_2D,1,GL_RGBA32F,window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glBindImageTexture(0, stencilTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F));
            glCheck(glBindTexture(GL_TEXTURE_2D, 0));
            std::vector<GLfloat> stencilClearBuf(window.getView().getSize().x*window.getView().getSize().y*4, 0);
            glCheck(glGenBuffers(1, &clearBuf2));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf2));
            glCheck(glBufferData(GL_PIXEL_UNPACK_BUFFER, stencilClearBuf.size() * sizeof(GLfloat),
            &stencilClearBuf[0], GL_STATIC_COPY));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
 
            alphaBuffer.create(window.getView().getSize().x, window.getView().getSize().y, settings);
            glCheck(glGenTextures(1, &alphaTex));
            glCheck(glBindTexture(GL_TEXTURE_2D, alphaTex));
            glCheck(glTexStorage2D(GL_TEXTURE_2D,1,GL_RGBA32F,window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glBindImageTexture(0, alphaTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F));
            glCheck(glBindTexture(GL_TEXTURE_2D, 0));
            std::vector<GLfloat> alphaClearBuf(window.getView().getSize().x*window.getView().getSize().y*4, 0);
            glCheck(glGenBuffers(1, &clearBuf3));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf3));
            glCheck(glBufferData(GL_PIXEL_UNPACK_BUFFER, alphaClearBuf.size() * sizeof(GLfloat),
            &alphaClearBuf[0], GL_STATIC_COPY));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
            alphaBufferSprite = Sprite(alphaBuffer.getTexture(), math::Vec3f(0, 0, 0), math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0), sf::IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
            //Debug image.
            shadowMap.create(resolution.x, resolution.y,settings);
            shadowTile = Sprite(shadowMap.getTexture(), math::Vec3f(0, 0, 0), math::Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0), IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glGenBuffers(1, &atomicBuffer));
            glCheck(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicBuffer));
            glCheck(glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), nullptr, GL_DYNAMIC_DRAW));
            glCheck(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0));
            glCheck(glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomicBuffer));
            glCheck(glGenTextures(1, &frameBufferTex));
            glCheck(glBindTexture(GL_TEXTURE_2D, frameBufferTex));
            glCheck(glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, window.getView().getSize().x, window.getView().getSize().y));
            glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
            glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
            glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
            glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
            glCheck(glBindImageTexture(0, frameBufferTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F));
            glCheck(glBindTexture(GL_TEXTURE_2D, 0));
            std::vector<GLfloat> texClearBuf(window.getView().getSize().x*window.getView().getSize().y*4, 0);
            glCheck(glGenBuffers(1, &clearBuf4));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf4));
            glCheck(glBufferData(GL_PIXEL_UNPACK_BUFFER, texClearBuf.size() * sizeof(GLfloat),
            &texClearBuf[0], GL_STATIC_COPY));
            glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
                core::FastDelegate<bool> signal (&ShadowRenderComponent::needToUpdate, this);
                core::FastDelegate<void> slot (&ShadowRenderComponent::drawNextFrame, this);
                core::Command cmd(signal, slot);
                getListener().connect("UPDATE", cmd);
                glCheck(glGenBuffers(1, &vboWorldMatrices));
                glCheck(glGenBuffers(1, &vboIndirect));
                if (settings.versionMajor >= 3 && settings.versionMinor >= 3) {
                    glGenBuffers(1, &vboWorldMatrices);
                    glGenBuffers(1, &vboShadowProjMatrices);
                    const std::string  simpleVertexShader = R"(#version 460
                                                        layout (location = 0) in vec3 position;
                                                        layout (location = 1) in vec4 color;
                                                        layout (location = 2) in vec2 texCoords;
                                                        layout (location = 3) in vec3 normals;
                                                        uniform mat4 projectionMatrix;
                                                        uniform mat4 viewMatrix;
                                                        uniform mat4 worldMat;
                                                        void main () {
                                                            gl_Position = projectionMatrix * viewMatrix * worldMat * vec4(position, 1.f);
                                                        })";
                    const std::string simpleFragmentShader = R"(#version 460
                                                                layout(origin_upper_left) in vec4 gl_FragCoord;
                                                                layout(rgba32f, binding = 0) uniform image2D img_output;
                                                                layout(location = 0) out vec4 fcolor;
                                                                void main() {
                                                                    fcolor = imageLoad(img_output, ivec2(gl_FragCoord.xy));
                                                                })";
                    const std::string buildDepthBufferVertexShaderNormal = R"(#version 460
                                                                              layout (location = 0) in vec3 position;
                                                                              layout (location = 1) in vec4 color;
                                                                              layout (location = 2) in vec2 texCoords;
                                                                              layout (location = 3) in vec3 normals;
                                                                              layout (location = 4) in uint textureIndex;
                                                                              layout (location = 6) in uint l;
                                                                              uniform mat4 projectionMatrix;
                                                                              uniform mat4 viewMatrix;
                                                                              uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                              out vec2 fTexCoords;
                                                                              out vec4 frontColor;
                                                                              out uint texIndex;
                                                                              out uint layer;
                                                                              void main() {
                                                                                  gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.f);
                                                                                  fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                                  frontColor = color;
                                                                                  texIndex = textureIndex;
                                                                                  layer = l;
                                                                              }
                                                                              )";
                    const std::string buildDepthBufferVertexShader = R"(#version 460
                                                                        layout (location = 0) in vec3 position;
                                                                        layout (location = 1) in vec4 color;
                                                                        layout (location = 2) in vec2 texCoords;
                                                                        layout (location = 3) in vec3 normals;
                                                                        layout (location = 4) in mat4 worldMat;
                                                                        layout (location = 12) in uint textureIndex;
                                                                        layout (location = 14) in uint l;
                                                                        uniform mat4 projectionMatrix;
                                                                        uniform mat4 viewMatrix;
                                                                        uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                        out vec2 fTexCoords;
                                                                        out vec4 frontColor;
                                                                        out uint texIndex;
                                                                        out uint layer;
                                                                        void main() {
                                                                            gl_Position = projectionMatrix * viewMatrix * worldMat * vec4(position, 1.f);
                                                                            fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                            frontColor = color;
                                                                            texIndex = textureIndex;
                                                                            layer = l;
                                                                        }
                                                                     )";
                     const std::string buildDepthBufferFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
 
                                                                          layout(binding = 0, rgba32f) uniform image2D depthBuffer;
                                                                          layout (location = 0) out vec4 fColor;
 
                                                                          void main () {
                                                                              vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                              float z = gl_FragCoord.z;
                                                                              float l = layer;
                                                                              vec4 depth = imageLoad(depthBuffer,ivec2(gl_FragCoord.xy));
                                                                              if (l > depth.y || l == depth.y && z > depth.z) {
                                                                                fColor = vec4(0, l, z, texel.a);
                                                                                imageStore(depthBuffer,ivec2(gl_FragCoord.xy),vec4(0,l,z,texel.a));
                                                                              } else {
                                                                                fColor = depth;
                                                                              }
                                                                          }
                                                                        )";
                     const std::string buildAlphaBufferFragmentShader = R"(#version 460
                                                                      #extension GL_ARB_bindless_texture : enable
                                                                      layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                        sampler2D textures[200];
                                                                      };
                                                                      layout(binding = 0, rgba32f) uniform image2D alphaBuffer;
                                                                      layout (location = 0) out vec4 fColor;
                                                                      uniform sampler2D depthBuffer;
                                                                      uniform sampler2D stencilBuffer;
                                                                      uniform vec3 resolution;
                                                                      uniform mat4 lviewMatrix;
                                                                      uniform mat4 lprojectionMatrix;
                                                                      in vec4 frontColor;
                                                                      in vec2 fTexCoords;
                                                                      in flat uint texIndex;
                                                                      in flat uint layer;
                                                                      in vec4 shadowCoords;
                                                                      void main() {
                                                                          vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                          float current_alpha = texel.a;
                                                                          vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                          vec4 depth = texture2D (depthBuffer, position);
                                                                          vec4 alpha = imageLoad(alphaBuffer,ivec2(gl_FragCoord.xy));
                                                                          vec3 projCoords = shadowCoords.xyz / shadowCoords.w;
                                                                          projCoords = projCoords * 0.5 + 0.5;
                                                                          vec4 stencil = texture2D (stencilBuffer, projCoords.xy);
                                                                          float l = layer;
                                                                          float z = gl_FragCoord.z;
                                                                          if (l > stencil.y || l == stencil.y && stencil.z > projCoords.z && depth.z > z && current_alpha > alpha.a) {
                                                                              fColor = vec4(0, 1, z, current_alpha);
                                                                              imageStore(alphaBuffer,ivec2(gl_FragCoord.xy),vec4(0, l, z, current_alpha));
                                                                          } else {
                                                                              fColor = alpha;
                                                                          }
                                                                      }
                                                                      )";
                    /*const std::string buildShadowMapVertexShaderNormal = R"(#version 460
                                                                            layout (location = 0) in vec3 position;
                                                                            layout (location = 1) in vec4 color;
                                                                            layout (location = 2) in vec2 texCoords;
                                                                            layout (location = 3) in vec3 normals;
                                                                            uniform mat4 projectionMatrix;
                                                                            uniform mat4 viewMatrix;
                                                                            uniform mat4 textureMatrix;
                                                                            out vec2 fTexCoords;
                                                                            out vec4 frontColor;
                                                                            void main() {
                                                                                gl_Position = projectionMatrix * viewMatrix  * vec4(position, 1.f);
                                                                                fTexCoords = (textureMatrix * vec4(texCoords, 1.f, 1.f)).xy;
                                                                                frontColor = color;
                                                                            }
                                                                        )";
                    const std::string buildShadowMapVertexShader = R"(#version 460
                                                                      layout (location = 0) in vec3 position;
                                                                      layout (location = 1) in vec4 color;
                                                                      layout (location = 2) in vec2 texCoords;
                                                                      layout (location = 3) in vec3 normals;
                                                                      layout (location = 4) in mat4 worldMat;
                                                                      uniform mat4 projectionMatrix;
                                                                      uniform mat4 viewMatrix;
                                                                      uniform mat4 textureMatrix;
                                                                      out vec2 fTexCoords;
                                                                      out vec4 frontColor;
                                                                      void main() {
                                                                          gl_Position = projectionMatrix * viewMatrix  * worldMat * vec4(position, 1.f);
                                                                          fTexCoords = (textureMatrix * vec4(texCoords, 1.f, 1.f)).xy;
                                                                          frontColor = color;
                                                                      }
                                                                    )";*/
                    const std::string buildShadowMapFragmentShader = R"(#version 460
                                                                        #extension GL_ARB_bindless_texture : enable
                                                                        in vec4 frontColor;
                                                                        in vec2 fTexCoords;
 
                                                                        layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                            sampler2D textures[200];
                                                                        };
                                                                        in flat uint texIndex;
                                                                        in flat uint layer;
                                                                        layout(binding = 0, rgba32f) uniform image2D stencilBuffer;
                                                                        layout (location = 0) out vec4 fColor;
                                                                        void main() {
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
                                                                            float current_alpha = texel.a;
                                                                            vec4 alpha = imageLoad(stencilBuffer,ivec2(gl_FragCoord.xy));
                                                                            float l = layer;
                                                                            float z = gl_FragCoord.z;
                                                                            if (/*l > alpha.y || l == alpha.y &&*/ z > alpha.z) {
                                                                                fColor = vec4(0, l, z, current_alpha);
                                                                                imageStore(stencilBuffer,ivec2(gl_FragCoord.xy),vec4(0, l, z, current_alpha));
                                                                            } else {
                                                                                fColor = alpha;
                                                                            }
                                                                        }
                                                                    )";
                        const std::string perPixShadowVertexShader = R"(#version 460
                                                                   layout (location = 0) in vec3 position;
                                                                   layout (location = 1) in vec4 color;
                                                                   layout (location = 2) in vec2 texCoords;
                                                                   layout (location = 3) in vec3 normals;
                                                                   layout (location = 4) in mat4 worldMat;
                                                                   layout (location = 8) in mat4 shadowProjMat;
                                                                   layout (location = 12) in uint textureIndex;
                                                                   layout (location = 14) in uint l;
                                                                   uniform mat4 projectionMatrix;
                                                                   uniform mat4 viewMatrix;
                                                                   uniform mat4 lviewMatrix;
                                                                   uniform mat4 lprojectionMatrix;
                                                                   uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                   out vec4 shadowCoords;
                                                                   out vec4 frontColor;
                                                                   out vec2 fTexCoords;
                                                                   out uint texIndex;
                                                                   out uint layer;
                                                                   void main() {
                                                                       gl_Position = projectionMatrix * viewMatrix * shadowProjMat * worldMat * vec4(position, 1.f);
                                                                       fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                       frontColor = color;
                                                                       shadowCoords = lprojectionMatrix * lviewMatrix * shadowProjMat * worldMat * vec4(position, 1);
                                                                       texIndex = textureIndex;
                                                                       layer = l;
                                                                   }
                                                                  )";
                        const std::string perPixShadowNormalVertexShader = R"(#version 460
                                                                   layout (location = 0) in vec3 position;
                                                                   layout (location = 1) in vec4 color;
                                                                   layout (location = 2) in vec2 texCoords;
                                                                   layout (location = 3) in vec3 normals;
                                                                   layout (location = 4) in uint textureIndex;
                                                                   layout (location = 6) in uint l;
                                                                   uniform mat4 projectionMatrix;
                                                                   uniform mat4 viewMatrix;
                                                                   uniform mat4 lviewMatrix;
                                                                   uniform mat4 lprojectionMatrix;
                                                                   uniform mat4 textureMatrix[)"+core::conversionUIntString(Texture::getAllTextures().size())+R"(];
                                                                   out vec4 shadowCoords;
                                                                   out vec4 frontColor;
                                                                   out vec2 fTexCoords;
                                                                   out uint texIndex;
                                                                   out uint layer;
                                                                   void main() {
                                                                       gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.f);
                                                                       fTexCoords = (textureIndex != 0) ? (textureMatrix[textureIndex-1] * vec4(texCoords, 1.f, 1.f)).xy : texCoords;
                                                                       frontColor = color;
                                                                       shadowCoords = lprojectionMatrix * lviewMatrix * vec4(position, 1);
                                                                       texIndex = textureIndex;
                                                                       layer = l;
                                                                   }
                                                                  )";
                        const std::string perPixShadowFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 shadowCoords;
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          uniform sampler2D texture;
                                                                          uniform sampler2D stencilBuffer;
                                                                          uniform sampler2D depthBuffer;
                                                                          uniform sampler2D alphaBuffer;
                                                                          uniform float haveTexture;
                                                                          uniform vec3 resolution;
                                                                          layout (std140, binding = 0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
                                                                          layout (location = 0) out vec4 fColor;
                                                                          layout(rgba32f, binding = 0) uniform image2D img_output;
                                                                          layout(binding = 0, offset = 0) uniform atomic_uint nextNodeCounter;
 
                                                                         /*Functions to debug, draw numbers to the image,
                                                                          draw a vertical ligne*/
                                                                          void drawVLine (ivec2 position, int width, int nbPixels, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y < startY + nbPixels) {
                                                                                 while (position.x < startX + width) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y++;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          /*Draw an horizontal line*/
                                                                          void drawHLine (ivec2 position, int height, int nbPixels, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y > startY - height) {
                                                                                 while (position.x < startX + nbPixels) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y--;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          /*Draw digits.*/
                                                                          void drawDigit (ivec2 position, int nbPixels, vec4 color, uint digit) {
                                                                              int digitSize = nbPixels * 10;
                                                                              if (digit == 0) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(position, digitSize, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 1) {
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                              } else if (digit == 2) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 3) {
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 4) {
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 5) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 6) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(position, digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 7) {
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                              } else if (digit == 8) {
                                                                                  drawHLine(position, digitSize, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              } else if (digit == 9) {
                                                                                  drawVLine(position, digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x + digitSize / 2 - nbPixels, position.y), digitSize, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                  drawHLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2 + nbPixels / 2, nbPixels, color);
                                                                                  drawVLine(ivec2(position.x, position.y - digitSize + nbPixels), digitSize / 2, nbPixels, color);
                                                                              }
                                                                          }
                                                                          void drawSquare(ivec2 position, int size, vec4 color) {
                                                                              int startY = position.y;
                                                                              int startX = position.x;
                                                                              while (position.y > startY - size) {
                                                                                 while (position.x < startX + size) {
                                                                                    imageStore(img_output, position, color);
                                                                                    position.x++;
                                                                                 }
                                                                                 position.y--;
                                                                                 position.x = startX;
                                                                              }
                                                                          }
                                                                          void drawPunt(ivec2 position, int nbPixels, vec4 color) {
                                                                              int puntSize = nbPixels * 2;
                                                                              drawSquare(position, puntSize, color);
                                                                          })" \
                                                                          R"(ivec2 print (ivec2 position, int nbPixels, vec4 color, double number) {
                                                                              int digitSize = nbPixels * 10;
                                                                              int digitSpacing = nbPixels * 6;
                                                                              if (number < 0) {
                                                                                 number = -number;
                                                                                 drawVLine(ivec2(position.x, position.y - digitSize / 2 + nbPixels / 2), digitSize / 2, nbPixels, color);
                                                                                 position.x += digitSpacing;
                                                                              }
                                                                              int pe = int(number);
                                                                              int n = 0;
                                                                              uint rpe[10];
                                                                              do {
                                                                                 uint digit = pe % 10;
                                                                                 pe /= 10;
                                                                                 if (n < 10) {
                                                                                    rpe[n] = digit;
                                                                                 }
                                                                                 n++;
                                                                              } while (pe != 0);
                                                                              if (n >= 10)
                                                                                n = 9;
                                                                              //drawDigit(position, nbPixels, color,0);
                                                                              for (int i = n-1; i >= 0; i--) {
                                                                                 drawDigit(position, nbPixels, color, rpe[i]);
                                                                                 //drawDigit(position, nbPixels, color,n-i-1);
                                                                                 position.x += digitSpacing;
                                                                              }
                                                                              double rest = fract(number);
                                                                              if (rest > 0) {
                                                                                  drawPunt(position, nbPixels, color);
                                                                                  position.x += digitSpacing;
                                                                                  do {
                                                                                     rest *= 10;
                                                                                     int digit = int(rest);
                                                                                     rest -= digit;
                                                                                     drawDigit(position, nbPixels, color, digit);
                                                                                     position.x += digitSpacing;
                                                                                  } while (rest != 0);
                                                                              }
                                                                              return position;
                                                                          }
                                                                          ivec2 print (ivec2 position, int nbPixels, vec4 color, mat4 matrix) {
                                                                              int numberSpacing = 10;
                                                                              for (uint i = 0; i < 4; i++) {
                                                                                 for (uint j = 0; j < 4; j++) {
                                                                                    position = print(position, nbPixels, color, matrix[i][j]);
                                                                                    position.x += numberSpacing;
                                                                                 }
                                                                              }
                                                                              return position;
                                                                          }
                                                                          ivec2 print (ivec2 position, int nbPixels, vec4 color, vec4 vector) {
                                                                              int numberSpacing = 10;
                                                                              for (uint i = 0; i < 4; i++) {
                                                                                position = print(position, nbPixels, color, vector[i]);
                                                                                position.x += numberSpacing;
                                                                              }
                                                                              return position;
                                                                          }
                                                                        void main() {
                                                                            uint fragmentIdx = atomicCounterIncrement(nextNodeCounter);
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture2D(depthBuffer, position);
                                                                            vec4 alpha = texture2D(alphaBuffer, position);
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
 
                                                                            float color = texel.a;
                                                                            vec3 projCoords = shadowCoords.xyz / shadowCoords.w;
                                                                            projCoords = projCoords * 0.5 + 0.5;
                                                                            vec4 stencil = texture2D (stencilBuffer, projCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            vec4 visibility;
                                                                            uint l = layer;
                                                                            if (l > stencil.y || l == stencil.y && stencil.z > projCoords.z) {
                                                                                if (depth.z > z) {
                                                                                    visibility = vec4 (1, 1, 1, alpha.a);
                                                                                } else {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }
                                                                            if (fragmentIdx == 0)
                                                                                print(ivec2(200, 100), 1, vec4(1, 0, 0, 1), vec4(0, 0, projCoords.z, stencil.z));
                                                                            fColor = visibility;
                                                                          }
                                                                          )";
                        if (!debugShader.loadFromMemory(simpleVertexShader, simpleFragmentShader)) {
                            throw core::Erreur(51, "Failed to load debug shader", 0);
                        }
                        if (!depthGenShader.loadFromMemory(buildDepthBufferVertexShader, buildDepthBufferFragmentShader))  {
                            throw core::Erreur(52, "Error, failed to load build depth buffer shader", 3);
                        }
                        if (!depthGenNormalShader.loadFromMemory(buildDepthBufferVertexShaderNormal, buildDepthBufferFragmentShader)) {
                            throw core::Erreur(51, "Error, failed to load build depth buffer normal shader", 3);
                        }
                        if (!buildShadowMapShader.loadFromMemory(buildDepthBufferVertexShader, buildShadowMapFragmentShader)) {
                            throw core::Erreur(53, "Error, failed to load build shadow map shader", 3);
                        }
                        if (!buildShadowMapNormalShader.loadFromMemory(buildDepthBufferVertexShaderNormal, buildShadowMapFragmentShader)) {
                            throw core::Erreur(50, "Error, failed to load build shadow map normal shader", 3);
                        }
                        if (!perPixShadowShader.loadFromMemory(perPixShadowVertexShader, perPixShadowFragmentShader)) {
                            throw core::Erreur(54, "Error, failed to load per pix shadow map shader", 3);
                        }
                        if (!perPixShadowShaderNormal.loadFromMemory(perPixShadowNormalVertexShader, perPixShadowFragmentShader)) {
                            throw core::Erreur(55, "Error, failed to load per pix normal shadow map shader", 3);
                        }
                        if (!sBuildAlphaBufferShader.loadFromMemory(perPixShadowVertexShader,buildAlphaBufferFragmentShader)) {
                            throw core::Erreur(60, "Error, failed to load build alpha buffer shader", 3);
                        }
                        if (!sBuildAlphaBufferNormalShader.loadFromMemory(perPixShadowNormalVertexShader,buildAlphaBufferFragmentShader)) {
                            throw core::Erreur(61, "Error, failed to load build alpha normal buffer shader", 3);
                        }
                        math::Matrix4f viewMatrix = window.getDefaultView().getViewMatrix().getMatrix().transpose();
                        math::Matrix4f projMatrix = window.getDefaultView().getProjMatrix().getMatrix().transpose();
                        debugShader.setParameter("projectionMatrix", projMatrix);
                        debugShader.setParameter("viewMatrix", viewMatrix);
                        depthGenShader.setParameter("texture", Shader::CurrentTexture);
                        buildShadowMapShader.setParameter("texture", Shader::CurrentTexture);
                        depthGenNormalShader.setParameter("texture", Shader::CurrentTexture);
                        buildShadowMapNormalShader.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        perPixShadowShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        perPixShadowShader.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        perPixShadowShader.setParameter("alphaBuffer", alphaBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("depthBuffer", depthBuffer.getTexture());
                        perPixShadowShaderNormal.setParameter("texture", Shader::CurrentTexture);
                        perPixShadowShaderNormal.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        perPixShadowShaderNormal.setParameter("alphaBuffer", alphaBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        sBuildAlphaBufferShader.setParameter("texture", Shader::CurrentTexture);
                        sBuildAlphaBufferShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        sBuildAlphaBufferNormalShader.setParameter("depthBuffer", depthBuffer.getTexture());
                        sBuildAlphaBufferNormalShader.setParameter("stencilBuffer", stencilBuffer.getTexture());
                        sBuildAlphaBufferNormalShader.setParameter("texture", Shader::CurrentTexture);
                        sBuildAlphaBufferNormalShader.setParameter("resolution", resolution.x, resolution.y, resolution.z);
                        std::vector<Texture*> allTextures = Texture::getAllTextures();
                        Samplers allSamplers{};
                        std::vector<math::Matrix4f> textureMatrices;
                        for (unsigned int i = 0; i < allTextures.size(); i++) {
                            textureMatrices.push_back(allTextures[i]->getTextureMatrix());
                            GLuint64 handle_texture = allTextures[i]->getTextureHandle();
                            allTextures[i]->makeTextureResident(handle_texture);
                            allSamplers.tex[i].handle = handle_texture;
                            //std::cout<<"add texture i : "<<i<<" id : "<<allTextures[i]->getNativeHandle()<<std::endl;
                        }
                        buildShadowMapNormalShader.setParameter("textureMatrix", textureMatrices);
                        buildShadowMapShader.setParameter("textureMatrix", textureMatrices);
                        depthGenShader.setParameter("textureMatrix", textureMatrices);
                        depthGenNormalShader.setParameter("textureMatrix", textureMatrices);
                        perPixShadowShader.setParameter("textureMatrix", textureMatrices);
                        perPixShadowShaderNormal.setParameter("textureMatrix", textureMatrices);
                        sBuildAlphaBufferNormalShader.setParameter("textureMatrix", textureMatrices);
                        sBuildAlphaBufferShader.setParameter("textureMatrix", textureMatrices);
 
 
                        unsigned int ubid;
                        glCheck(ubid = glGetUniformBlockIndex(buildShadowMapShader.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(buildShadowMapShader.getHandle(),    ubid, 0));
                        glCheck(ubid = glGetUniformBlockIndex(buildShadowMapNormalShader.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(buildShadowMapNormalShader.getHandle(),    ubid, 0));
                        glCheck(ubid = glGetUniformBlockIndex(depthGenShader.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(depthGenShader.getHandle(),    ubid, 0));
                        glCheck(ubid = glGetUniformBlockIndex(depthGenNormalShader.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(depthGenNormalShader.getHandle(),    ubid, 0));
                        glCheck(ubid = glGetUniformBlockIndex(perPixShadowShader.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(perPixShadowShader.getHandle(),    ubid, 0));
                        glCheck(ubid = glGetUniformBlockIndex(perPixShadowShaderNormal.getHandle(), "ALL_TEXTURES"));
                        glCheck(glUniformBlockBinding(perPixShadowShaderNormal.getHandle(),    ubid, 0));
 
                        glCheck(glGenBuffers(1, &ubo));
                        glCheck(glBindBuffer(GL_UNIFORM_BUFFER, ubo));
                        glCheck(glBufferData(GL_UNIFORM_BUFFER, sizeof(Samplers),allSamplers.tex, GL_STATIC_DRAW));
                        glCheck(glBindBuffer(GL_UNIFORM_BUFFER, 0));
                        glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                        stencilBuffer.setActive();
                        glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                        depthBuffer.setActive();
                        glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                        alphaBuffer.setActive();
                        glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                        //std::cout<<"size : "<<sizeof(Samplers)<<" "<<alignof (alignas(16) uint64_t[200])<<std::endl;
 
                        /*glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo2));
                        glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo3));*/
 
 
                        for (unsigned int i = 0; i < Batcher::nbPrimitiveTypes; i++) {
                            vbBindlessTex[i].setPrimitiveType(static_cast<sf::PrimitiveType>(i));
                        }
                    }
 
                }
            }
            void ShadowRenderComponent::loadTextureIndexes() {
                std::vector<Texture*> allTextures = Texture::getAllTextures();
                Samplers allSamplers{};
                std::vector<math::Matrix4f> textureMatrices;
                for (unsigned int i = 0; i < allTextures.size(); i++) {
                    textureMatrices.push_back(allTextures[i]->getTextureMatrix());
                    GLuint64 handle_texture = allTextures[i]->getTextureHandle();
                    allTextures[i]->makeTextureResident(handle_texture);
                    allSamplers.tex[i].handle = handle_texture;
                    //std::cout<<"add texture i : "<<i<<" id : "<<allTextures[i]->getNativeHandle()<<std::endl;
                }
                glCheck(glBindBuffer(GL_UNIFORM_BUFFER, ubo));
                glCheck(glBufferData(GL_UNIFORM_BUFFER, sizeof(Samplers),allSamplers.tex, GL_STATIC_DRAW));
                glCheck(glBindBuffer(GL_UNIFORM_BUFFER, 0));
            }
            void ShadowRenderComponent::onVisibilityChanged(bool visible) {
                if (visible) {
                    glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                } else {
                    glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, 0));
                }
            }
            void ShadowRenderComponent::drawInstanced() {
                for (unsigned int i = 0; i < Batcher::nbPrimitiveTypes; i++) {
                    vbBindlessTex[i].clear();
                }
                std::array<std::vector<DrawArraysIndirectCommand>, Batcher::nbPrimitiveTypes> drawArraysIndirectCommands;
                std::array<std::vector<float>, Batcher::nbPrimitiveTypes> matrices, matrices2;
                std::array<unsigned int, Batcher::nbPrimitiveTypes> firstIndex, baseInstance;
                for (unsigned int i = 0; i < firstIndex.size(); i++) {
                    firstIndex[i] = 0;
                }
                for (unsigned int i = 0; i < baseInstance.size(); i++) {
                    baseInstance[i] = 0;
                }
                for (unsigned int i = 0; i < m_instances.size(); i++) {
                    if (m_instances[i].getAllVertices().getVertexCount() > 0) {
                        unsigned int p = m_instances[i].getAllVertices().getPrimitiveType();
                        DrawArraysIndirectCommand drawArraysIndirectCommand;
                        std::vector<TransformMatrix*> tm = m_instances[i].getTransforms();
                        for (unsigned int j = 0; j < tm.size(); j++) {
                            tm[j]->update();
                            std::array<float, 16> matrix = tm[j]->getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices[p].push_back(matrix[n]);
                            }
                        }
                        unsigned int vertexCount = 0;
                        if (m_instances[i].getVertexArrays().size() > 0) {
                            Entity* entity = m_instances[i].getVertexArrays()[0]->getEntity();
                            for (unsigned int j = 0; j < m_instances[i].getVertexArrays().size(); j++) {
                                if (entity == m_instances[i].getVertexArrays()[j]->getEntity()) {
                                    unsigned int p = m_instances[i].getVertexArrays()[j]->getPrimitiveType();
                                    for (unsigned int k = 0; k < m_instances[i].getVertexArrays()[j]->getVertexCount(); k++) {
                                        vertexCount++;
                                        vbBindlessTex[p].append((*m_instances[i].getVertexArrays()[j])[k], (m_instances[i].getMaterial().getTexture() != nullptr) ? m_instances[i].getMaterial().getTexture()->getId() : 0);
                                        vbBindlessTex[p].addLayer(m_instances[i].getMaterial().getLayer());
                                    }
                                }
                            }
                        }
                        drawArraysIndirectCommand.count = vertexCount;
                        drawArraysIndirectCommand.firstIndex = firstIndex[p];
                        drawArraysIndirectCommand.baseInstance = baseInstance[p];
                        drawArraysIndirectCommand.instanceCount = tm.size();
                        drawArraysIndirectCommands[p].push_back(drawArraysIndirectCommand);
                        firstIndex[p] += vertexCount;
                        baseInstance[p] += tm.size();
                    }
                }
                glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                glCheck(glBufferData(GL_ARRAY_BUFFER, matrices.size() * sizeof(float), &matrices[0], GL_DYNAMIC_DRAW));
                glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawArraysIndirectCommands.size() * sizeof(DrawArraysIndirectCommand), &drawArraysIndirectCommands[0], GL_DYNAMIC_DRAW));
                glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                RenderStates currentStates;
                currentStates.blendMode = sf::BlendNone;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawArraysIndirectCommands[p].size() * sizeof(DrawArraysIndirectCommand), &drawArraysIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        currentStates.shader = &buildShadowMapShader;
                        stencilBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawArraysIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices);
                        currentStates.shader = &depthGenShader;
                        depthBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawArraysIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices);
                        vbBindlessTex[p].clear();
                    }
                }
                glCheck(glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT));
                physic::BoundingBox viewArea = view.getViewVolume();
                math::Vec3f position (viewArea.getPosition().x,viewArea.getPosition().y, view.getPosition().z);
                math::Vec3f size (viewArea.getWidth(), viewArea.getHeight(), 0);
                stencilBuffer.display();
                stencilBufferTile.setPosition(position);
                depthBuffer.display();
                depthBufferTile.setPosition(position);
                shadowMap.setView(view);
                for (unsigned int i = 0; i < firstIndex.size(); i++) {
                    firstIndex[i] = 0;
                }
                for (unsigned int i = 0; i < baseInstance.size(); i++) {
                    baseInstance[i] = 0;
                }
                for (unsigned int i = 0; i < matrices.size(); i++) {
                    matrices[i].clear();
                }
                for (unsigned int i = 0; i < drawArraysIndirectCommands.size(); i++) {
                    drawArraysIndirectCommands[i].clear();
                }
                for (unsigned int i = 0; i < m_shadow_instances.size(); i++) {
                    DrawArraysIndirectCommand drawArraysIndirectCommand;
                    unsigned int p = m_shadow_instances[i].getAllVertices().getPrimitiveType();
                    if (m_shadow_instances[i].getAllVertices().getVertexCount() > 0) {
                        std::vector<TransformMatrix*> tm = m_shadow_instances[i].getTransforms();
                        for (unsigned int j = 0; j < tm.size(); j++) {
                            tm[j]->update();
                            std::array<float, 16> matrix = tm[j]->getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices[p].push_back(matrix[n]);
                            }
                        }
 
                        std::vector<TransformMatrix> tm2 = m_shadow_instances[i].getShadowProjMatrix();
                        for (unsigned int j = 0; j < tm2.size(); j++) {
                            tm2[j].update();
                            std::array<float, 16> matrix = tm2[j].getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices2[p].push_back(matrix[n]);
                            }
                        }
                        unsigned int vertexCount=0;
                        if (m_shadow_instances[i].getVertexArrays().size() > 0) {
                            Entity* entity = m_shadow_instances[i].getVertexArrays()[0]->getEntity();
                            for (unsigned int j = 0; j < m_shadow_instances[i].getVertexArrays().size(); j++) {
                                if (entity == m_shadow_instances[i].getVertexArrays()[j]->getEntity()) {
                                    unsigned int p = m_shadow_instances[i].getVertexArrays()[j]->getPrimitiveType();
                                    for (unsigned int k = 0; k < m_shadow_instances[i].getVertexArrays()[j]->getVertexCount(); k++) {
                                        vertexCount++;
                                        vbBindlessTex[p].append((*m_shadow_instances[i].getVertexArrays()[j])[k], (m_shadow_instances[i].getMaterial().getTexture() != nullptr) ? m_shadow_instances[i].getMaterial().getTexture()->getId() : 0);
                                        vbBindlessTex[p].addLayer(m_shadow_instances[i].getMaterial().getLayer());
                                    }
                                }
                            }
                        }
                        drawArraysIndirectCommand.count = vertexCount;
                        drawArraysIndirectCommand.firstIndex = firstIndex[p];
                        drawArraysIndirectCommand.baseInstance = baseInstance[p];
                        drawArraysIndirectCommand.instanceCount = tm.size();
                        drawArraysIndirectCommands[p].push_back(drawArraysIndirectCommand);
                        firstIndex[p] += vertexCount;
                        baseInstance[p] += tm.size();
                    }
                }
                currentStates.shader = &sBuildAlphaBufferShader;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboShadowProjMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices2[p].size() * sizeof(float), &matrices2[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawArraysIndirectCommands[p].size() * sizeof(DrawArraysIndirectCommand), &drawArraysIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        alphaBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawArraysIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices, vboShadowProjMatrices);
                    }
                }
                glCheck(glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT));
                currentStates.shader = &perPixShadowShader;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboShadowProjMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices2[p].size() * sizeof(float), &matrices2[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawArraysIndirectCommands[p].size() * sizeof(DrawArraysIndirectCommand), &drawArraysIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        shadowMap.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawArraysIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices, vboShadowProjMatrices);
                        vbBindlessTex[p].clear();
                    }
                }
                shadowMap.display();
            }
            void ShadowRenderComponent::drawInstancedIndexed() {
                for (unsigned int i = 0; i < Batcher::nbPrimitiveTypes; i++) {
                    vbBindlessTex[i].clear();
                }
                std::array<std::vector<DrawElementsIndirectCommand>, Batcher::nbPrimitiveTypes> drawElementsIndirectCommands;
                std::array<std::vector<float>, Batcher::nbPrimitiveTypes> matrices, matrices2;
                std::array<unsigned int, Batcher::nbPrimitiveTypes> firstIndex, baseInstance, baseVertex;
                for (unsigned int i = 0; i < firstIndex.size(); i++) {
                firstIndex[i] = 0;
                }
                for (unsigned int i = 0; i < baseVertex.size(); i++) {
                    baseVertex[i] = 0;
                }
                for (unsigned int i = 0; i < baseInstance.size(); i++) {
                    baseInstance[i] = 0;
                }
                for (unsigned int i = 0; i < m_instancesIndexed.size(); i++) {
                    DrawElementsIndirectCommand drawElementsIndirectCommand;
                    if (m_instancesIndexed[i].getAllVertices().getVertexCount() > 0) {
                        unsigned int p = m_instancesIndexed[i].getAllVertices().getPrimitiveType();
                        std::vector<TransformMatrix*> tm = m_instancesIndexed[i].getTransforms();
                        for (unsigned int j = 0; j < tm.size(); j++) {
                            tm[j]->update();
                            std::array<float, 16> matrix = tm[j]->getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices[p].push_back(matrix[n]);
                            }
                        }
                        unsigned int vertexCount = 0, indexCount = 0;
                        if (m_instancesIndexed[i].getVertexArrays().size() > 0) {
                            Entity* entity = m_instancesIndexed[i].getVertexArrays()[0]->getEntity();
                            for (unsigned int j = 0; j < m_instancesIndexed[i].getVertexArrays().size(); j++) {
                                if (entity == m_instancesIndexed[i].getVertexArrays()[j]->getEntity()) {
                                    unsigned int p = m_instancesIndexed[i].getVertexArrays()[j]->getPrimitiveType();
                                    for (unsigned int k = 0; k < m_instancesIndexed[i].getVertexArrays()[j]->getVertexCount(); k++) {
                                        vertexCount++;
                                        vbBindlessTex[p].append((*m_instancesIndexed[i].getVertexArrays()[j])[k], (m_instancesIndexed[i].getMaterial().getTexture() != nullptr) ? m_instancesIndexed[i].getMaterial().getTexture()->getId() : 0);
                                        vbBindlessTex[p].addLayer(m_instancesIndexed[i].getMaterial().getLayer());
                                    }
                                    for (unsigned int k = 0; k < m_instancesIndexed[i].getVertexArrays()[j]->getIndexes().size(); k++) {
                                        indexCount++;
                                        vbBindlessTex[p].addIndex(m_instancesIndexed[i].getVertexArrays()[j]->getIndexes()[k]);
                                    }
                                }
                            }
                        }
                        drawElementsIndirectCommand.index_count = indexCount;
                        drawElementsIndirectCommand.first_index = firstIndex[p];
                        drawElementsIndirectCommand.instance_base = baseInstance[p];
                        drawElementsIndirectCommand.vertex_base = baseVertex[p];
                        drawElementsIndirectCommand.instance_count = tm.size();
                        drawElementsIndirectCommands[p].push_back(drawElementsIndirectCommand);
                        firstIndex[p] += indexCount;
                        baseVertex[p] += vertexCount;
                        baseInstance[p] += tm.size();
                    }
                }
                RenderStates currentStates;
                currentStates.blendMode = sf::BlendNone;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawElementsIndirectCommands[p].size() * sizeof(DrawElementsIndirectCommand), &drawElementsIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        currentStates.shader = &buildShadowMapShader;
                        stencilBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawElementsIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices);
                        currentStates.shader = &depthGenShader;
                        depthBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawElementsIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices);
                        vbBindlessTex[p].clear();
                    }
                }
                physic::BoundingBox viewArea = view.getViewVolume();
                math::Vec3f position (viewArea.getPosition().x,viewArea.getPosition().y, view.getPosition().z);
                math::Vec3f size (viewArea.getWidth(), viewArea.getHeight(), 0);
                stencilBuffer.display();
                stencilBufferTile.setPosition(position);
                depthBuffer.display();
                depthBufferTile.setPosition(position);
                shadowMap.setView(view);
                for (unsigned int i = 0; i < firstIndex.size(); i++) {
                firstIndex[i] = 0;
                }
                for (unsigned int i = 0; i < baseVertex.size(); i++) {
                    baseVertex[i] = 0;
                }
                for (unsigned int i = 0; i < baseInstance.size(); i++) {
                    baseInstance[i] = 0;
                }
                for (unsigned int i = 0; i < matrices.size(); i++) {
                    matrices[i].clear();
                }
                for (unsigned int i = 0; i < drawElementsIndirectCommands.size(); i++) {
                    drawElementsIndirectCommands[i].clear();
                }
                for (unsigned int i = 0; i < m_shadow_instances_indexed.size(); i++) {
                    DrawElementsIndirectCommand drawElementsIndirectCommand;
                    if (m_shadow_instances_indexed[i].getAllVertices().getVertexCount() > 0) {
                        unsigned int p = m_shadow_instances_indexed[i].getAllVertices().getPrimitiveType();
                        std::vector<TransformMatrix*> tm = m_shadow_instances_indexed[i].getTransforms();
                        for (unsigned int j = 0; j < tm.size(); j++) {
                            tm[j]->update();
                            std::array<float, 16> matrix = tm[j]->getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices[p].push_back(matrix[n]);
                            }
                        }
 
                        std::vector<TransformMatrix> tm2 = m_shadow_instances_indexed[i].getShadowProjMatrix();
                        for (unsigned int j = 0; j < tm2.size(); j++) {
                            tm2[j].update();
                            std::array<float, 16> matrix = tm2[j].getMatrix().transpose().toGlMatrix();
                            for (unsigned int n = 0; n < 16; n++) {
                                matrices2[p].push_back(matrix[n]);
                            }
                        }
                        unsigned int vertexCount = 0, indexCount = 0;
                        if (m_shadow_instances_indexed[i].getVertexArrays().size() > 0) {
                            Entity* entity = m_shadow_instances_indexed[i].getVertexArrays()[0]->getEntity();
                            for (unsigned int j = 0; j < m_shadow_instances_indexed[i].getVertexArrays().size(); j++) {
                                if (entity == m_shadow_instances_indexed[i].getVertexArrays()[j]->getEntity()) {
                                    unsigned int p = m_shadow_instances_indexed[i].getVertexArrays()[j]->getPrimitiveType();
                                    for (unsigned int k = 0; k < m_shadow_instances_indexed[i].getVertexArrays()[j]->getVertexCount(); k++) {
                                        vertexCount++;
                                        vbBindlessTex[p].append((*m_shadow_instances_indexed[i].getVertexArrays()[j])[k], (m_shadow_instances_indexed[i].getMaterial().getTexture() != nullptr) ? m_shadow_instances_indexed[i].getMaterial().getTexture()->getId() : 0);
                                        vbBindlessTex[p].addLayer(m_shadow_instances_indexed[i].getMaterial().getLayer());
                                    }
                                        for (unsigned int k = 0; k < m_shadow_instances_indexed[i].getVertexArrays()[j]->getIndexes().size(); k++) {
                                        indexCount++;
                                        vbBindlessTex[p].addIndex(m_shadow_instances_indexed[i].getVertexArrays()[j]->getIndexes()[k]);
                                    }
                                }
                            }
                        }
                        drawElementsIndirectCommand.index_count = indexCount;
                        drawElementsIndirectCommand.first_index = firstIndex[p];
                        drawElementsIndirectCommand.instance_base = baseInstance[p];
                        drawElementsIndirectCommand.vertex_base = baseVertex[p];
                        drawElementsIndirectCommand.instance_count = tm.size();
                        drawElementsIndirectCommands[p].push_back(drawElementsIndirectCommand);
                        firstIndex[p] += indexCount;
                        baseVertex[p] += vertexCount;
                        baseInstance[p] += tm.size();
                    }
                }
                currentStates.shader = &sBuildAlphaBufferShader;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboShadowProjMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices2[p].size() * sizeof(float), &matrices2[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawElementsIndirectCommands[p].size() * sizeof(DrawElementsIndirectCommand), &drawElementsIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        alphaBuffer.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawElementsIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices, vboShadowProjMatrices);
                    }
                }
                currentStates.shader = &perPixShadowShader;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboWorldMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices[p].size() * sizeof(float), &matrices[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboShadowProjMatrices));
                        glCheck(glBufferData(GL_ARRAY_BUFFER, matrices2[p].size() * sizeof(float), &matrices2[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, vboIndirect));
                        glCheck(glBufferData(GL_DRAW_INDIRECT_BUFFER, drawElementsIndirectCommands[p].size() * sizeof(DrawElementsIndirectCommand), &drawElementsIndirectCommands[p][0], GL_DYNAMIC_DRAW));
                        glCheck(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
                        vbBindlessTex[p].update();
                        shadowMap.drawIndirect(vbBindlessTex[p], vbBindlessTex[p].getPrimitiveType(), drawElementsIndirectCommands[p].size(), currentStates, vboIndirect, vboWorldMatrices, vboShadowProjMatrices);
                        vbBindlessTex[p].clear();
                    }
                }
                shadowMap.display();
            }
            void ShadowRenderComponent::drawNormal() {
                for (unsigned int i = 0; i < Batcher::nbPrimitiveTypes; i++) {
                    vbBindlessTex[i].clear();
                }
                for (unsigned int i = 0; i < m_normals.size(); i++) {
                   if (m_normals[i].getAllVertices().getVertexCount() > 0) {
                        unsigned int p = m_normals[i].getAllVertices().getPrimitiveType();
                        for (unsigned int j = 0; j < m_normals[i].getAllVertices().getVertexCount(); j++) {
                            vbBindlessTex[p].append(m_normals[i].getAllVertices()[j],(m_normals[i].getMaterial().getTexture() != nullptr) ? m_normals[i].getMaterial().getTexture()->getNativeHandle() : 0);
                            vbBindlessTex[p].addLayer(m_normals[i].getMaterial().getLayer());
                        }
                    }
                }
                RenderStates states;
                states.blendMode = sf::BlendNone;
                states.texture = nullptr;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        states.shader = &depthGenNormalShader;
                        vbBindlessTex[p].update();
                        depthBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                        states.shader = &buildShadowMapNormalShader;
                        stencilBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                        vbBindlessTex[p].clear();
                    }
                }
                glCheck(glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT));
                stencilBuffer.display();
                depthBuffer.display();
                for (unsigned int i = 0; i < m_shadow_normals.size(); i++) {
                    if (m_shadow_normals[i].getAllVertices().getVertexCount() > 0) {
 
 
 
                        unsigned int p = m_shadow_normals[i].getAllVertices().getPrimitiveType();
                        for (unsigned int j = 0; j < m_shadow_normals[i].getAllVertices().getVertexCount(); j++) {
                            vbBindlessTex[p].append(m_shadow_normals[i].getAllVertices()[j],(m_shadow_normals[i].getMaterial().getTexture() != nullptr) ? m_shadow_normals[i].getMaterial().getTexture()->getNativeHandle() : 0);
                            vbBindlessTex[p].addLayer(m_shadow_normals[i].getMaterial().getLayer());
                        }
 
                    }
                }
                states.shader=&sBuildAlphaBufferNormalShader;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        vbBindlessTex[p].update();
                        alphaBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                    }
                }
                glCheck(glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT));
                alphaBuffer.display();
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    states.shader=&perPixShadowShaderNormal;
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        vbBindlessTex[p].update();
                        shadowMap.drawVertexBuffer(vbBindlessTex[p], states);
                        vbBindlessTex[p].clear();
                    }
                }
                glCheck(glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT));
                shadowMap.display();
            }
            void ShadowRenderComponent::drawNormalIndexed() {
                for (unsigned int i = 0; i < m_normalsIndexed.size(); i++) {
                   if (m_normalsIndexed[i].getAllVertices().getVertexCount() > 0) {
                        unsigned int p = m_normalsIndexed[i].getAllVertices().getPrimitiveType();
                        for (unsigned int j = 0; j < m_normalsIndexed[i].getAllVertices().getVertexCount(); j++) {
                            vbBindlessTex[p].append(m_normalsIndexed[i].getAllVertices()[j],(m_normalsIndexed[i].getMaterial().getTexture() != nullptr) ? m_normalsIndexed[i].getMaterial().getTexture()->getNativeHandle() : 0);
                            vbBindlessTex[p].addLayer(m_normalsIndexed[i].getMaterial().getLayer());
                        }
                        for (unsigned int j = 0; j < m_normalsIndexed[i].getAllVertices().getIndexes().size(); j++) {
                            vbBindlessTex[p].addIndex(m_normalsIndexed[i].getAllVertices().getIndexes()[j]);
                        }
                    }
                }
                RenderStates states;
                states.blendMode = sf::BlendNone;
                states.shader = &depthGenNormalShader;
                states.texture = nullptr;
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        states.shader = &depthGenNormalShader;
                        vbBindlessTex[p].update();
                        depthBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                        states.shader = &buildShadowMapNormalShader;
                        stencilBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                        vbBindlessTex[p].clear();
                    }
                }
                stencilBuffer.display();
                depthBuffer.display();
                for (unsigned int i = 0; i < m_shadow_normalsIndexed.size(); i++) {
                    if (m_shadow_normalsIndexed[i].getAllVertices().getVertexCount() > 0) {
 
 
 
                        unsigned int p = m_shadow_normalsIndexed[i].getAllVertices().getPrimitiveType();
                        for (unsigned int j = 0; j < m_shadow_normalsIndexed[i].getAllVertices().getVertexCount(); j++) {
                            vbBindlessTex[p].append(m_shadow_normalsIndexed[i].getAllVertices()[j],(m_shadow_normalsIndexed[i].getMaterial().getTexture() != nullptr) ? m_shadow_normalsIndexed[i].getMaterial().getTexture()->getNativeHandle() : 0);
                            vbBindlessTex[p].addLayer(m_shadow_normalsIndexed[i].getMaterial().getLayer());
                        }
                        for (unsigned int j = 0; j < m_shadow_normalsIndexed[i].getAllVertices().getIndexes().size(); j++) {
                            vbBindlessTex[p].addIndex(m_shadow_normalsIndexed[i].getAllVertices().getIndexes()[j]);
                        }
                    }
                }
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    states.shader=&sBuildAlphaBufferNormalShader;
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        vbBindlessTex[p].update();
                        alphaBuffer.drawVertexBuffer(vbBindlessTex[p], states);
                    }
                }
                alphaBuffer.display();
                for (unsigned int p = 0; p < Batcher::nbPrimitiveTypes; p++) {
                    states.shader=&perPixShadowShaderNormal;
                    if (vbBindlessTex[p].getVertexCount() > 0) {
                        vbBindlessTex[p].update();
                        shadowMap.drawVertexBuffer(vbBindlessTex[p], states);
                        vbBindlessTex[p].clear();
                    }
                }
                shadowMap.display();
            }
            void ShadowRenderComponent::drawNextFrame() {
                //glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo));
                math::Vec3f centerLight = g2d::AmbientLight::getAmbientLight().getLightCenter();
 
                View lightView = View(view.getSize().x, view.getSize().y, -g2d::AmbientLight::getAmbientLight().getHeight(), g2d::AmbientLight::getAmbientLight().getHeight());
                lightView.setCenter(centerLight);
                math::Vec3f forward = (view.getPosition() - lightView.getPosition()).normalize();
                math::Vec3f target = lightView.getPosition() + forward;
                lightView.lookAt(target.x, target.y, target.z);
                stencilBuffer.setView(lightView);
                depthBuffer.setView(view);
                math::Matrix4f lviewMatrix = lightView.getViewMatrix().getMatrix().transpose();
                math::Matrix4f lprojMatrix = lightView.getProjMatrix().getMatrix().transpose();
                buildShadowMapShader.setParameter("projectionMatrix", lprojMatrix);
                buildShadowMapShader.setParameter("viewMatrix", lviewMatrix);
                buildShadowMapNormalShader.setParameter("projectionMatrix", lprojMatrix);
                buildShadowMapNormalShader.setParameter("viewMatrix", lviewMatrix);
                math::Matrix4f viewMatrix = view.getViewMatrix().getMatrix().transpose();
                math::Matrix4f projMatrix = view.getProjMatrix().getMatrix().transpose();
                depthGenShader.setParameter("projectionMatrix", projMatrix);
                depthGenShader.setParameter("viewMatrix", viewMatrix);
                depthGenNormalShader.setParameter("projectionMatrix", projMatrix);
                depthGenNormalShader.setParameter("viewMatrix", viewMatrix);
                perPixShadowShader.setParameter("projectionMatrix", projMatrix);
                perPixShadowShader.setParameter("viewMatrix", viewMatrix);
                perPixShadowShader.setParameter("lviewMatrix", lviewMatrix);
                perPixShadowShader.setParameter("lprojectionMatrix", lprojMatrix);
                perPixShadowShaderNormal.setParameter("projectionMatrix", projMatrix);
                perPixShadowShaderNormal.setParameter("viewMatrix", viewMatrix);
                perPixShadowShaderNormal.setParameter("lviewMatrix", lviewMatrix);
                perPixShadowShaderNormal.setParameter("lprojectionMatrix", lprojMatrix);
                sBuildAlphaBufferShader.setParameter("projectionMatrix", projMatrix);
                sBuildAlphaBufferShader.setParameter("viewMatrix", viewMatrix);
                sBuildAlphaBufferShader.setParameter("lviewMatrix", lviewMatrix);
                sBuildAlphaBufferShader.setParameter("lprojectionMatrix", lviewMatrix);
                sBuildAlphaBufferNormalShader.setParameter("projectionMatrix", projMatrix);
                sBuildAlphaBufferNormalShader.setParameter("viewMatrix", viewMatrix);
                sBuildAlphaBufferNormalShader.setParameter("lviewMatrix", lviewMatrix);
                sBuildAlphaBufferNormalShader.setParameter("lprojectionMatrix", lviewMatrix);
                drawInstanced();
                drawInstancedIndexed();
                drawNormal();
                drawNormalIndexed();
                glCheck(glFinish());
                vb.clear();
            //vb.name = "";
                vb.setPrimitiveType(sf::Quads);
                Vertex v1 (sf::Vector3f(0, 0, quad.getSize().z));
                Vertex v2 (sf::Vector3f(quad.getSize().x,0, quad.getSize().z));
                Vertex v3 (sf::Vector3f(quad.getSize().x, quad.getSize().y, quad.getSize().z));
                Vertex v4 (sf::Vector3f(0, quad.getSize().y, quad.getSize().z));
                vb.append(v1);
                vb.append(v2);
                vb.append(v3);
                vb.append(v4);
                vb.update();
                math::Matrix4f matrix = quad.getTransform().getMatrix().transpose();
                debugShader.setParameter("worldMat", matrix);
                RenderStates currentStates;
                currentStates.blendMode = sf::BlendAlpha;
                currentStates.shader = &debugShader;
                currentStates.texture = nullptr;
                shadowMap.drawVertexBuffer(vb, currentStates);
                glCheck(glFinish());
                shadowMap.display();
                    //glCheck(glBindBufferBase(GL_UNIFORM_BUFFER, 0, 0));
 
            }
            std::vector<Entity*> ShadowRenderComponent::getEntities() {
                return visibleEntities;
            }
            void ShadowRenderComponent::draw(RenderTarget& target, RenderStates states) {
                shadowTile.setCenter(target.getView().getPosition());
                states.blendMode = sf::BlendMultiply;
                target.draw(shadowTile, states);
            }
            void ShadowRenderComponent::pushEvent(window::IEvent event, RenderWindow& rw) {
                if (event.type == window::IEvent::WINDOW_EVENT && event.window.type == window::IEvent::WINDOW_EVENT_RESIZED && &getWindow() == &rw && isAutoResized()) {
                    recomputeSize();
                    getListener().pushEvent(event);
                    getView().reset(physic::BoundingBox(getView().getViewport().getPosition().x, getView().getViewport().getPosition().y, getView().getViewport().getPosition().z, event.window.data1, event.window.data2, getView().getViewport().getDepth()));
                }
            }
            bool ShadowRenderComponent::needToUpdate() {
                return update;
            }
            View& ShadowRenderComponent::getView() {
                return view;
            }
            int ShadowRenderComponent::getLayer() {
                return getPosition().z;
            }
            const Texture& ShadowRenderComponent::getStencilBufferTexture() {
                return stencilBuffer.getTexture();
            }
            const Texture& ShadowRenderComponent::getShadowMapTexture() {
                return shadowMap.getTexture();
            }
            Sprite& ShadowRenderComponent::getFrameBufferTile () {
                return stencilBufferTile;
            }
            Sprite& ShadowRenderComponent::getDepthBufferTile() {
                return shadowTile;
            }
            void ShadowRenderComponent::setExpression(std::string expression) {
                update = true;
                this->expression = expression;
            }
            std::string ShadowRenderComponent::getExpression() {
                return expression;
            }
            void ShadowRenderComponent::setView(View view) {
                this->view = view;/*View(view.getSize().x, view.getSize().y, view.getPosition().z, view.getDepth());
                this->view.setCenter(view.getPosition());*/
                shadowMap.setView(this->view);
                depthBuffer.setView(this->view);
                alphaBuffer.setView(this->view);
            }
            bool ShadowRenderComponent::loadEntitiesOnComponent(std::vector<Entity*> vEntities)
            {
 
                batcher.clear();
                normalBatcher.clear();
                shadowBatcher.clear();
                normalShadowBatcher.clear();
                batcherIndexed.clear();
                shadowBatcherIndexed.clear();
                normalBatcherIndexed.clear();
                normalShadowBatcherIndexed.clear();
 
                for (unsigned int i = 0; i < vEntities.size(); i++) {
                    if ( vEntities[i]->isLeaf()) {
                        Entity* entity = vEntities[i]->getRootEntity();
                        math::Vec3f shadowOrigin, shadowCenter, shadowScale(1.f, 1.f, 1.f), shadowRotationAxis, shadowTranslation;
                        float shadowRotationAngle = 0;
                        //if (entity != nullptr && entity->isModel()) {
                            shadowCenter = entity->getShadowCenter();
                            shadowScale = entity->getShadowScale();
                            shadowRotationAxis = entity->getShadowRotationAxis();
                            shadowRotationAngle = entity->getShadowRotationAngle();
                            shadowOrigin = entity->getPosition();
                            shadowTranslation = entity->getPosition() + shadowCenter;
                            /*if (entity->getType() == "E_WALL") {
                                std::cout<<"shadow center : "<<shadowCenter<<std::endl;
                                std::cout<<"shadow scale : "<<shadowScale<<std::endl;
                                std::cout<<"shadow rotation axis : "<<shadowRotationAxis<<std::endl;
                                std::cout<<"shadow rotation angle : "<<shadowRotationAngle<<std::endl;
                                std::cout<<"shadow origin : "<<shadowOrigin<<std::endl;
                                std::cout<<"shadow translation : "<<shadowTranslation<<std::endl;
                            }*/
                        //}
                        TransformMatrix tm;
                        tm.setOrigin(shadowOrigin);
                        tm.setScale(shadowScale);
                        tm.setRotation(shadowRotationAxis, shadowRotationAngle);
                        tm.setTranslation(shadowTranslation);
 
                        for (unsigned int j = 0; j <  vEntities[i]->getNbFaces(); j++) {
 
                             if(vEntities[i]->getDrawMode() == Entity::INSTANCED) {
                                if (vEntities[i]->getFace(j)->getVertexArray().getIndexes().size() == 0) {
                                    batcher.addFace( vEntities[i]->getFace(j));
                                    shadowBatcher.addShadowFace(vEntities[i]->getFace(j),  view.getViewMatrix(), tm);
                                } else {
                                    batcherIndexed.addFace( vEntities[i]->getFace(j));
                                    shadowBatcherIndexed.addShadowFace(vEntities[i]->getFace(j),  view.getViewMatrix(), tm);
                                }
                             } else {
                                 if (vEntities[i]->getFace(j)->getVertexArray().getIndexes().size() == 0) {
                                    normalBatcher.addFace( vEntities[i]->getFace(j));
                                    if (vEntities[i]->getRootEntity()->getType() != "E_BIGTILE")
                                        normalShadowBatcher.addShadowFace(vEntities[i]->getFace(j), view.getViewMatrix(), tm);
                                 } else {
                                    normalBatcherIndexed.addFace( vEntities[i]->getFace(j));
                                    normalShadowBatcherIndexed.addShadowFace(vEntities[i]->getFace(j), view.getViewMatrix(), tm);
                                 }
                             }
                        }
                    }
                }
                m_instances = batcher.getInstances();
                m_normals = normalBatcher.getInstances();
                m_shadow_instances = shadowBatcher.getInstances();
                m_shadow_normals = normalShadowBatcher.getInstances();
                m_instancesIndexed = batcherIndexed.getInstances();
                m_shadow_instances_indexed = shadowBatcherIndexed.getInstances();
                m_normalsIndexed = normalBatcherIndexed.getInstances();
                m_shadow_normalsIndexed = normalShadowBatcherIndexed.getInstances();
                visibleEntities = vEntities;
                update = true;
                return true;
            }
            void ShadowRenderComponent::clear() {
                 shadowMap.clear(sf::Color::White);
                 depthBuffer.clear(sf::Color::Transparent);
                 stencilBuffer.clear(sf::Color::Transparent);
                 alphaBuffer.clear(sf::Color::Transparent);
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf));
                 glCheck(glBindTexture(GL_TEXTURE_2D, depthTex));
                 glCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view.getSize().x, view.getSize().y, GL_RGBA,
                 GL_FLOAT, NULL));
                 glCheck(glBindTexture(GL_TEXTURE_2D, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf2));
                 glCheck(glBindTexture(GL_TEXTURE_2D, stencilTex));
                 glCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view.getSize().x, view.getSize().y, GL_RGBA,
                 GL_FLOAT, NULL));
                 glCheck(glBindTexture(GL_TEXTURE_2D, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf3));
                 glCheck(glBindTexture(GL_TEXTURE_2D, alphaTex));
                 glCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view.getSize().x, view.getSize().y, GL_RGBA,
                 GL_FLOAT, NULL));
                 glCheck(glBindTexture(GL_TEXTURE_2D, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, clearBuf4));
                 glCheck(glBindTexture(GL_TEXTURE_2D, frameBufferTex));
                 glCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view.getSize().x, view.getSize().y, GL_RGBA,
                 GL_FLOAT, NULL));
                 glCheck(glBindTexture(GL_TEXTURE_2D, 0));
                 glCheck(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
                 GLuint zero = 0;
                 glCheck(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicBuffer));
                 glCheck(glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), &zero));
                 glCheck(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0));
            }
            RenderTexture* ShadowRenderComponent::getFrameBuffer() {
                return &shadowMap;
            }
            ShadowRenderComponent::~ShadowRenderComponent() {
                glDeleteBuffers(1, &vboWorldMatrices);
                glDeleteBuffers(1, &vboShadowProjMatrices);
                glDeleteBuffers(1, &ubo);
            }
            #endif // VULKAN
        }
    }

J'ai aussi des problèmes lorsque je veux testé les collisions des ombres avec le depthbuffer, j'ai aussi des fragments dont la position en z n'est pas bonne ...

Merci.

[Laurent7601]

Salut! Je me suis trompé, déjà pour la lumière c'était ça :

Code :

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

1
2
3
4
5
6
7
math::Vec3f centerLight = g2d::AmbientLight::getAmbientLight().getLightCenter();
 
                View lightView = View(view.getSize().x, view.getSize().y, 0, g2d::AmbientLight::getAmbientLight().getHeight());
                lightView.setCenter(centerLight);
                math::Vec3f forward = (lightView.getPosition() - view.getPosition()).normalize();
                math::Vec3f target = lightView.getPosition() + forward;
                lightView.lookAt(target.x, target.y, target.z);

Et j'ai inversé le signe dans mes shaders j'ai mit stencil.z < proCoords.z au lieu de stencil.z > projCoords.z parce que apparemment le z est plus petit lorsque l'objet est plus proche de la lumière hors que le z est plus grand lorsque les objets sont plus près je ne comprend pas vraiment enfin bref..., je me suis peut être trompé c'est peut être l'inverse, bref, maintenant faut que je règle ce problème de collision des ombres avec la depthTexture.

[Laurent7601]

Il y a quelque chose d'étrange, l'ombre s'affiche bien au bonne endroit mais lorsque je veux récupérer le z sur la depthTexture à la position de l'ombre, ça récupère pas le z au bonne endroit sur la texture :

Code :

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

1
2
3
 
vec2 position = (gl_FragCoord.xy / resolution.xy);
vec4 depth = texture2D(depthBuffer, position);

si gl_FragCoord.xy n'était pas bon, je crois que l'ombre ne s'afficherait pas au bonne endroit, et résolution est la taille de la fenêtre.

[Laurent7601]

Quand je compare le z de la depthTexture avec le z de l'ombre, j'ai des résultats bizarres certains pixels de l'ombre s'affichent d'autre pas...



Pourtant il n'y a rien devant l'ombre.

[Mat.M]

Salut!
-Je rend les objets sur ma shadowMap en coordonnées lumière.
Merci.

le problème ne vient-il pas de là ? La shadow map s'applique à plat or dans là dans ce cas elle est appliqué sur des polygones sensés décrire un relief.

[Laurent7601]

Oui le problème vient de là dans le turoriel la shadow map est appliquée sur un terrain plat mais je ne vois pas comment faire avec un relief j'ai tenté de faire une matrice de transformation des ombres pour projeter l'ombre sur la pente mais le résultat n'est pas satisfaisant et le z en coordonnées écran de mes ombres est trop petit.

Bref il doit y avoir une technique mais je ne la connais pas.

[Mat.M]

bonsoir
la solution serait de prendre chaque mesh une par une ou bien le relief généré par triangulations et boucler sur chaque face,contraster la face ou pas.
Autant dire que ça risque de prendre des FPS
surtout avec une scène comprenant plusieurs meshes

[LittleWhite]

Bonjour,

Je vais tenter de piocher dans mes souvenirs, mais de mémoire :

• les shadow maps fonctionnent aussi sur des reliefs, fort heureusement (sinon on ne tenterait même pas de faire des cascaded shadow maps pour simuler les ombres produites par le soleil). Voir GPU Gems ou https://github.com/GKR/NvidiaCascadedShadowMapsGLM ;
• lorsque vous effectuez le rendu d'un pixel, vous devez réussir à transformer les coordonnées de ce pixel dans l'espace de la shadow map, ainsi, vous savez s'il est dans l'ombre ou pas. Du coup, ce calcul doit être fait pour chaque shadow map/lumière existante, pour chaque pixel. Mais ça va, les multiplications de matrices, c'est la raison d'être d'un GPU.

j'ai tenté de faire une matrice de transformation des ombres pour projeter l'ombre sur la pente

Autrement dit : non, on ne projette pas l'ombre sur une pente. On atténue le pixel de la pente suivant la valeur à la position de ce pixel dans la shadow map.

[Laurent7601]

Ok mais le soucis principal c'est si il y a quelque chose entre la caméra et l'ombre, j'ai tenté un bête depth test en comparant le z de l'ombre avec celui des objets de la scène :

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
void main() {
                                                                            uint fragmentIdx = atomicCounterIncrement(nextNodeCounter);
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture(depthBuffer, position);
                                                                            vec4 alpha = texture(alphaBuffer, position);
                                                                            vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords) : frontColor;
 
                                                                            float color = texel.a;
                                                                            vec3 projCoords = shadowCoords.xyz / shadowCoords.w;
                                                                            projCoords = projCoords * 0.5 + 0.5;
                                                                            vec4 stencil = texture (stencilBuffer, projCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            vec4 visibility;
                                                                            uint l = layer;
                                                                            if (l > stencil.y || l == stencil.y && stencil.z < projCoords.z) {
                                                                                if (depth.z > z) {
                                                                                    visibility = vec4 (1, 1, 1, alpha.a);
                                                                                } else {
                                                                                    visibility = vec4 (0.5, 0.5, 0.5, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }
                                                                            /*if (fragmentIdx == 0)
                                                                                print(ivec2(200, 100), 1, vec4(1, 0, 0, 1), vec4(0, 0, depth.z, z));*/
                                                                            fColor = visibility /*vec4(0, depth.z*100, z*100, 1)*/;
                                                                          }
                                                                          )";

Mais le résultat est bizarre ce n'est pas du tout ce à quoi je m'attendais.

Je ne comprend pas pourquoi j'ai des pixels de l'ombre qui clignotent et d'autres qui ne s'affichent pas.

[Laurent7601]

Salut! Je pensais que c'était un problème de synchronisation du fait que lors de la génération de la depthTexture j'écris et je lis dans mon image avec un seul et même shader j'ai donc rajouté un memoryBarrier() après l'écriture dans mon image parce que les valeurs de z dans ma depthTexture sont quand même bizarre.

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
#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
 
                                                                          layout(binding = 0, rgba32f) uniform image2D depthBuffer;
                                                                          layout (location = 0) out vec4 fColor;
 
                                                                          void main () {
                                                                              vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                              float z = gl_FragCoord.z;
                                                                              float l = layer;
                                                                              vec4 depth = imageLoad(depthBuffer,ivec2(gl_FragCoord.xy));
                                                                              if (l > depth.y || l == depth.y && z > depth.z) {
                                                                                fColor = vec4(0, l, z, texel.a);
                                                                                imageStore(depthBuffer,ivec2(gl_FragCoord.xy),vec4(0,l,z,texel.a));
                                                                                memoryBarrier();
                                                                              } else {
                                                                                fColor = depth;
                                                                              }
                                                                          }

Mais ça ne résous pas le problème mais je pense que le memoryBarrier() est nécessaire.

[LittleWhite]

Ok mais le soucis principal c'est si il y a quelque chose entre la caméra et l'ombre, j'ai tenté un bête depth test en comparant le z de l'ombre avec celui des objets de la scène.

Même en regardant la vidéo, c'est impossible de dire ce qui se passe. Le depth test est le même que lors d'un rendu classique. Le pixel du relief est affiché que s'il passe le test de profondeur. La shadow map n'a pas d'influence dessus.
Accessoirement, une technique de débogage classique pour ces problèmes, c'est d'afficher les cible de rendu (render target) à l'écran (dans un encart). Il y a même une fonction OpenGL facilitant ça.
Sinon, la solution plus pro, vu que la précédente est comparable à un printf(), c'est d'utiliser un débogueur (ici RenderDoc). Un peu dur à utiliser au premier abord, mais c'est un super outil (un débogueur quoi ).

[Laurent7601]

Ok parce que c'est très dur à déboguer ce genre de problème. Il faut comprendre pourquoi le z de certains pixels par rapport aux z de la depthmap sont pas bons. Pareil pour le test pour savoir si le pixel est dans l'ombre ou pas.

EDIT : Le problème c'est que renderdocs ne supporte pas le compatibility profile.

[Laurent7601]

Bon je vais devoir laisser tomber et passer à autre chose c'est indébuguable..., normalement ça devrait fonctionner comme un depthTest classique et ne pas afficher l'ombre si il y a quelque chose devant, j'ai essayé d'augmenter la valeur du zNear au cas ou quelque chose qui est trop devant la caméra viendrait cachez l'ombre mais dans ce cas ça ne m'affiche plus rien.

Bref je ne comprend vraiment pas je crois que je débuguerai ça plus tard pour pas perdre trop de temps sur l'avancement du projet.

En plus codexl de amd à fait planter windows j'ai dû reformater et tout réinstaller.

[Laurent7601]

Il me semble que opengl transforme mal mes sommets projetés en coordonnées écran pour la valeur z de mes pixels, pourtant mes matrices sont bonnes...

J'ai modifier le code du shader pour voir mieux le problème :

Code :

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

fColor = /*visibility*/ vec4(0, stencil.z*100, projCoords.z*100, 1);

On voit bien sur cette image qu'il y a quelque chose de pas normal, des pixels sont verts d'autres bleus hors qu'ils devraient être tous bleu parce que il n'y a rien entre la caméra et l'ombre.



Le tout maintenant est de savoir comment opengl converti les coordonnées envoyé à gl_Position dans le vertex shader en coordonnées écran.
Je suppose que ça les divises par w et que ça les multiplient par la matrice de viewport et pourquoi ça n'est pas bon.

[Laurent7601]

J'ai trouvé pourquoi le z de mes coordonnées côté opengl n'était pas bon parce que comme j'inverse la coordonnée en z dans ma matrice de projection, il fallait dire à opengl d'inverser les coordonnées en appelant cette fonction :

Code :

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

glClipControl(GL_UPPER_LEFT, GL_NEGATIVE_ONE_TO_ONE)

Maintenant ça va déjà mieux.

[LittleWhite]

Ok parce que c'est très dur à déboguer ce genre de problème.

Oui, en réalité, la programmation graphique, c'est "dur". C'est un domaine complet de l'informatique et de la programmation et comme tout, cela s'apprend.

EDIT : Le problème c'est que renderdocs ne supporte pas le compatibility profile.

Ah ! O_o

[Laurent7601]

C'est lorsque j'écris le z dans une image que ça ne va pas.
Lorsque je fais un bête depthTest en écrivant simplement la valeur de z du fragment ça marche.

J'ai donc changé mon shader :

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
#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
 
                                                                          layout(binding = 0, rgba32f) uniform image2D depthBuffer;
                                                                          layout (location = 0) out vec4 fColor;
 
                                                                          void main () {
                                                                              vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                              float z = gl_FragCoord.z;
                                                                              float l = layer;
                                                                              /*vec4 depth = imageLoad(depthBuffer,ivec2(gl_FragCoord.xy));
                                                                              if (l > depth.y || l == depth.y && z > depth.z) {
                                                                                fColor = vec4(0, l, z, texel.a);
                                                                                imageStore(depthBuffer,ivec2(gl_FragCoord.xy),vec4(0,l,z,texel.a));
                                                                                memoryBarrier();
                                                                              } else {
                                                                                fColor = depth;
                                                                              }*/
                                                                              fColor = vec4(0, l, z, texel.a);
                                                                          }

Je ne comprend pas pourquoi avec une image je n'ai pas la même chose qu'avec un depthTest classique enfin bref...

EDIT : un problème de synchronisation sûrement mais même avec memoryBarrier, ce qui est lu n'est pas ce qui a été écrit dans l'image avant apparement et je ne sais pas comment synchroniser celà.

[Laurent7601]

Salut! J'ai trouvé le problème!!!
Il fallait utiliser l’extension interlock.

J'ai donc modifier mon shader comme 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
const std::string buildDepthBufferFragmentShader = R"(#version 460
                                                                          #extension GL_ARB_bindless_texture : enable
                                                                          #extension GL_ARB_fragment_shader_interlock : require
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          in flat uint texIndex;
                                                                          in flat uint layer;
                                                                          layout(std140, binding=0) uniform ALL_TEXTURES {
                                                                              sampler2D textures[200];
                                                                          };
 
                                                                          layout(binding = 0, rgba32f) uniform image2D depthBuffer;
                                                                          layout (location = 0) out vec4 fColor;
 
                                                                          void main () {
                                                                              vec4 texel = (texIndex != 0) ? frontColor * texture2D(textures[texIndex-1], fTexCoords.xy) : frontColor;
                                                                              float z = gl_FragCoord.z;
                                                                              float l = layer;
                                                                              beginInvocationInterlockARB();
                                                                              vec4 depth = imageLoad(depthBuffer,ivec2(gl_FragCoord.xy));
                                                                              if (/*l > depth.y || l == depth.y &&*/ z > depth.z) {
                                                                                fColor = vec4(0, l, z, texel.a);
                                                                                imageStore(depthBuffer,ivec2(gl_FragCoord.xy),vec4(0,l,z,texel.a));
                                                                                memoryBarrier();
                                                                              } else {
                                                                                fColor = depth;
                                                                              }
                                                                              endInvocationInterlockARB();
                                                                          }
                                                                        )";

Et maintenant ça marche ma depthTexture est enfin bonne!!!
Résolu!

EDIT : à mon avis le problème c'était comme plusieurs invocation du fragment shader peuvent s'exécuter en parallèle pour un même pixel, ce qui était lu n'était pas forcément la dernière valeur écrite par le fragment shader du coup il faut empêcher l'exécution d'un autre shader pour ce même pixel tant que le shader n'a pas fini de s'exécuter. Je pensais que memoryBarrier et que coherent s'en chargeait mais appremment non ça ne fait que d'invoquer un shader pour la lecture et un shader pour l'écriture d'après ce que j'ai comprit. Bref la synchronisation au niveau du GPU ce n'est pas mon point fort j'ai encore du mal à comprendre comment ça fonctionne.