Problème avec sprites opaques qui deviennent semi-transparent.

Salut, j'ai trouvé une solution pour faire de l'OIT avec n couches de sprites malheureusement j'ai un problème avec les sprites opaques.

En fait je fais ceci : Je dessine d'abord le sprite le plus proche de la caméra ensuite je dessine tout les autres avec cette équation :

SRCCOLOR * ONEMINUSDSTALPHA + DSTCOLOR * DSTALPHA.

J'ai divisé l'équation en deux :

-Je fais la somme des valeurs de SRC_COLOR * ONEMINUSDSTALPHA et je les stockes dans une texture.
-Je fais la somme des valeurs de DSTCOLOR * DSTALPHA et je les stocke dans une deuxième textures.

-Je fais la moyenne (je divise la somme par le nombre de sprites) pour les deux textures.
Et pour avoir la couleur finale j'additionne les deux textures ensemble.

Ce qui niveau code me donne quelque chose comme ceci :
Code:
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
 
#include "../../../include/odfaeg/Graphics/oitRenderComponent.h"
#include "glCheck.h"
#include <memory.h>
using namespace sf;
using namespace std;
namespace odfaeg {
    namespace graphic {
        OITRenderComponent::OITRenderComponent (RenderWindow& window, int layer, std::string expression, sf::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()),
            expression(expression) {
            update = false;
            sf::Vector3i resolution ((int) window.getSize().x, (int) window.getSize().y, window.getView().getSize().z);
            settings.depthBits = 32;
            depthBuffer.create(resolution.x, resolution.y,settings);
            frontBuffer.create(resolution.x, resolution.y,settings);
            settings.depthBits = 0;
            averageBlendEqPart1.create(resolution.x, resolution.y,settings);
            averageBlendEqPart2.create(resolution.x, resolution.y,settings);
            alpha.create(resolution.x, resolution.y,settings);
            frameBuffer.create(resolution.x, resolution.y,settings);
 
            frontBuffer.setView(window.getView());
            depthBuffer.setView(window.getView());
            frameBuffer.setView(window.getView());
            frontBufferTile = std::make_unique<Tile>(&frontBuffer.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));
            depthBufferTile = std::make_unique<Tile>(&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));
            frameBufferTile = std::make_unique<Tile>(&frameBuffer.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));
            blendEqPart1 = std::make_unique<Tile>(&averageBlendEqPart1.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));
            blendEqPart2 = std::make_unique<Tile>(&averageBlendEqPart2.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));
            alphaTile = std::make_unique<Tile>(&alpha.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));
            core::FastDelegate<bool> signal (&OITRenderComponent::needToUpdate, this);
            core::FastDelegate<void> slot (&OITRenderComponent::drawNextFrame, this);
            core::Command cmd(signal, slot);
            getListener().connect("UPDATE", cmd);
            if (Shader::isAvailable()) {
                const std::string  vertexShader =
                "#version 130 \n"
                "out mat4 projMat;"
                "void main () {"
                    "gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
                    "gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;"
                    "gl_FrontColor = gl_Color;"
                    "projMat = gl_ProjectionMatrix;"
                "}";
                const std::string  simpleVertexShader =
                "#version 130 \n"
                "void main () {"
                    "gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
                    "gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;"
                    "gl_FrontColor = gl_Color;"
                "}";
                const std::string setAlphaFragShader =
                "#version 130 \n"
                "uniform vec3 resolution;"
                "uniform sampler2D frameBuffer;"
                "uniform sampler2D texture;"
                "void main() {"
                    "vec2 position = (gl_FragCoord.xy / resolution.xy);"
                    "vec4 color = texture2D(frameBuffer, position);"
                    "float alpha = texture2D(texture, gl_TexCoord[0].xy).a;"
                    "gl_FragColor = vec4(color.rgb, alpha);"
                "}";
                const std::string avgFragShader =
                "#version 130 \n"
                "uniform sampler2D texture;"
                "uniform float nb;"
                "void main() {"
                    "vec4 color = texture2D(texture, gl_TexCoord[0].xy);"
                    "gl_FragColor = vec4(color.r / nb, color.g / nb, color.b / nb, 1);"
                "}";
                const std::string depthGenFragShader =
                "#version 130 \n"
                "in mat4 projMat;"
                "uniform sampler2D texture;"
                "uniform float haveTexture;"
                "void main () {"
                    "vec4 texel = texture2D(texture, gl_TexCoord[0].xy);"
                    "vec4 colors[2];"
                    "colors[1] = texel * gl_Color;"
                    "colors[0] = gl_Color;"
                    "bool b = (haveTexture > 0.9);"
                    "vec4 color = colors[int(b)];"
                    "float z = (gl_FragCoord.w != 1.f) ? (inverse(projMat) * vec4(0, 0, 0, gl_FragCoord.w)).w : gl_FragCoord.z;"
                    "gl_FragColor = vec4(0, 0, z, color.a);"
                "}";
                const std::string frameBufferGenFragShader =
                "#version 130 \n"
                "uniform sampler2D depthBuffer;"
                "uniform sampler2D texture;"
                "uniform vec3 resolution;"
                "uniform float haveTexture;"
                "in mat4 projMat;"
                "void main () {"
                    "vec2 position = ( gl_FragCoord.xy / resolution.xy );"
                    "vec4 max = texture2D(depthBuffer, position);"
                    "vec4 texel = texture2D(texture, gl_TexCoord[0].xy);"
                    "vec4 colors[2];"
                    "colors[1] = texel * gl_Color;"
                    "colors[0] = gl_Color;"
                    "bool b = (haveTexture > 0.9);"
                    "vec4 color = colors[int(b)];"
                    "float z = (gl_FragCoord.w != 1.f) ? (inverse(projMat) * vec4(0, 0, 0, gl_FragCoord.w)).w : gl_FragCoord.z;"
                    "colors[1] = color;"
                    "colors[0] = vec4(0, 0, 0, 0);"
                    "b = (z < max.z);"
                    "gl_FragColor = colors[int(b)];"
                "}";
                if (!depthBufferGenerator.loadFromMemory(vertexShader, depthGenFragShader))
                    throw core::Erreur(50, "Failed to load depth buffer generator shader", 0);
                if (!frameBufferGenerator.loadFromMemory(vertexShader, frameBufferGenFragShader))
                    throw core::Erreur(51, "Failed to load frame buffer generator shader", 0);
                computeAvgShader.loadFromMemory(simpleVertexShader, avgFragShader);
                setAlphaShader.loadFromMemory(simpleVertexShader, setAlphaFragShader);
                setAlphaShader.setParameter("resolution",resolution.x, resolution.y, resolution.z);
                setAlphaShader.setParameter("frameBuffer", frameBuffer.getTexture());
                setAlphaShader.setParameter("texture", Shader::CurrentTexture);
                    //throw core::Erreur(52, "Failed to load specular texture generator shader", 0);
                /*if (!bumpTextureGenerator->loadFromMemory(vertexShader, bumpGenFragShader))
                    throw core::Erreur(53, "Failed to load bump texture generator shader", 0);
                if (!refractionTextureGenerator->loadFromMemory(vertexShader, refractionGenFragShader))
                    throw core::Erreur(54, "Failed to load refraction texture generator shader", 0);*/
                frameBufferGenerator.setParameter("resolution",resolution.x, resolution.y, resolution.z);
                frameBufferGenerator.setParameter("depthBuffer", depthBuffer.getTexture());
                frameBufferGenerator.setParameter("texture", Shader::CurrentTexture);
                depthBufferGenerator.setParameter("texture", Shader::CurrentTexture);
                computeAvgShader.setParameter("texture", Shader::CurrentTexture);
                //specularTextureGenerator->setParameter("specularTexture",specularTexture->getTexture());
                backgroundColor = sf::Color::Transparent;
            } else {
                throw core::Erreur(55, "Shader not supported!", 0);
            }
        }
        void OITRenderComponent::pushEvent(sf::Event event, RenderWindow& rw) {
            if (event.type == sf::Event::Resized && &getWindow() == &rw && isAutoResized()) {
                std::cout<<"recompute size"<<std::endl;
                recomputeSize();
                getListener().pushEvent(event);
                getView().reset(physic::BoundingBox(getView().getViewport().getPosition().x, getView().getViewport().getPosition().y, getView().getViewport().getPosition().z, event.size.width, event.size.height, getView().getViewport().getDepth()));
            }
        }
        bool OITRenderComponent::needToUpdate() {
            return update;
        }
        void OITRenderComponent::changeVisibleEntities(Entity* toRemove, Entity* toAdd, EntityManager* em) {
            bool removed;
            em->removeAnimatedVisibleEntity(toRemove, visibleEntities, view, removed);
            if (removed) {
                em->insertAnimatedVisibleEntity(toAdd, visibleEntities, view);
                loadEntitiesOnComponent(visibleEntities);
                update = true;
            }
        }
        std::string OITRenderComponent::getExpression() {
            return expression;
        }
        void OITRenderComponent::setBackgroundColor(sf::Color color) {
            this->backgroundColor = color;
        }
        void OITRenderComponent::clear() {
             frameBuffer.clear(backgroundColor);
             depthBuffer.clear(sf::Color::Transparent);
             frontBuffer.clear(sf::Color::Transparent);
             averageBlendEqPart1.clear(sf::Color::Transparent);
             averageBlendEqPart2.clear(sf::Color::Transparent);
             alpha.clear(sf::Color::Transparent);
        }
        Tile& OITRenderComponent::getAvgBlendEqPart1() {
            return *blendEqPart1;
        }
        Tile& OITRenderComponent::getAvgBlendEqPart2() {
            return *blendEqPart2;
        }
        Tile& OITRenderComponent::getFrameBufferTile () {
            return *frameBufferTile;
        }
        Tile& OITRenderComponent::getDepthBufferTile() {
            return *depthBufferTile;
        }
        Tile& OITRenderComponent::getFrontBufferTile() {
            return *frontBufferTile;
        }
        Tile& OITRenderComponent::getAlphaTile() {
            return *alphaTile;
        }
        const Texture& OITRenderComponent::getDepthBufferTexture() {
            return depthBuffer.getTexture();
        }
        const Texture& OITRenderComponent::getFrameBufferTexture() {
            return frameBuffer.getTexture();
        }
        const Texture& OITRenderComponent::getFrontBufferTexture() {
            return frontBuffer.getTexture();
        }
        bool OITRenderComponent::loadEntitiesOnComponent(std::vector<Entity*> vEntities)
        {
 
            batcher.clear();
            for (unsigned int i = 0; i < vEntities.size(); i++) {
                if ( vEntities[i]->isLeaf()) {
                    for (unsigned int j = 0; j <  vEntities[i]->getFaces().size(); j++) {
                         batcher.addFace( vEntities[i]->getFaces()[j]);
                    }
                }
            }
            m_instances = batcher.getInstances();
            visibleEntities = vEntities;
            update = true;
            return true;
        }
        void OITRenderComponent::setView(View view) {
            this->view = view;
            frameBuffer.setView(view);
            depthBuffer.setView(view);
            frontBuffer.setView(view);
            averageBlendEqPart1.setView(view);
            averageBlendEqPart2.setView(view);
            alpha.setView(view);
        }
        void OITRenderComponent::setExpression(std::string expression) {
            update = true;
            this->expression = expression;
        }
        void OITRenderComponent::drawNextFrame() {
            update = false;
            currentStates.blendMode = sf::BlendNone;
            for (unsigned int i = 0; i < m_instances.size(); i++) {
                 if (m_instances[i].getMaterial().getTexture() == nullptr)
                    depthBufferGenerator.setParameter("haveTexture", 0);
                 else
                    depthBufferGenerator.setParameter("haveTexture", 1);
 
                 currentStates.shader=&depthBufferGenerator;
                 currentStates.texture=m_instances[i].getMaterial().getTexture();
                 depthBuffer.draw(m_instances[i].getAllVertices(),currentStates);
                 currentStates.shader=nullptr;
                 frontBuffer.draw(m_instances[i].getAllVertices(), currentStates);
            }
            frontBuffer.display();
            frontBufferTile->setCenter(view.getPosition());
            /*frameBuffer->draw(*frontBufferTile, currentStates);
            currentStates.shader=frameBufferGenerator.get();
            currentStates.blendMode=sf::BlendMode(sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::DstAlpha, sf::BlendMode::Equation::Add, sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add);
            for (unsigned int i = 0; i < m_instances.size(); i++) {
                if (m_instances[i].getMaterial().getTexture() == nullptr)
                    frameBufferGenerator->setParameter("haveTexture", 0);
                 else
                    frameBufferGenerator->setParameter("haveTexture", 1);
                currentStates.texture = m_instances[i].getMaterial().getTexture();
                frameBuffer->draw(m_instances[i].getAllVertices(), currentStates);
            }*/
            averageBlendEqPart1.draw(*frontBufferTile, currentStates);
            averageBlendEqPart2.draw(*frontBufferTile, currentStates);
            currentStates.shader=&frameBufferGenerator;
            currentStates.blendMode=sf::BlendMode(sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add, sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add);
            for (unsigned int i = 0; i < m_instances.size(); i++) {
                if (m_instances[i].getMaterial().getTexture() == nullptr)
                    frameBufferGenerator.setParameter("haveTexture", 0);
                else
                    frameBufferGenerator.setParameter("haveTexture", 1);
                currentStates.texture = m_instances[i].getMaterial().getTexture();
                averageBlendEqPart1.draw(m_instances[i].getAllVertices(), currentStates);
            }
            currentStates.blendMode=sf::BlendMode(sf::BlendMode::Factor::DstAlpha,sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add, sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add);
            unsigned int nb = 0;
            for (unsigned int i = 0; i < m_instances.size(); i++) {
                if (m_instances[i].getMaterial().getTexture() == nullptr)
                    frameBufferGenerator.setParameter("haveTexture", 0);
                else
                    frameBufferGenerator.setParameter("haveTexture", 1);
                currentStates.texture = m_instances[i].getMaterial().getTexture();
                averageBlendEqPart2.draw(m_instances[i].getAllVertices(), currentStates);
                nb += m_instances[i].getVertexArrays().size();
            }
 
            currentStates.blendMode = sf::BlendMode(sf::BlendMode::Factor::Zero,sf::BlendMode::Factor::Zero,sf::BlendMode::Equation::Add, sf::BlendMode::Factor::OneMinusDstAlpha, sf::BlendMode::Factor::One, sf::BlendMode::Equation::Add);
            currentStates.shader = nullptr;
            alpha.draw(*frontBufferTile, currentStates);
            currentStates.shader=&frameBufferGenerator;
            for (unsigned int i = 0; i < m_instances.size(); i++) {
                if (m_instances[i].getMaterial().getTexture() == nullptr)
                    frameBufferGenerator.setParameter("haveTexture", 0);
                else
                    frameBufferGenerator.setParameter("haveTexture", 1);
                currentStates.texture = m_instances[i].getMaterial().getTexture();
                alpha.draw(m_instances[i].getAllVertices(), currentStates);
            }
            alpha.display();
            alphaTile->setCenter(view.getPosition());
            currentStates.blendMode=sf::BlendNone;
            computeAvgShader.setParameter("nb", nb);
            currentStates.shader = &computeAvgShader;
            averageBlendEqPart1.display();
            blendEqPart1->setCenter(view.getPosition());
            averageBlendEqPart1.draw(*blendEqPart1, currentStates);
            averageBlendEqPart2.display();
            blendEqPart2->setCenter(view.getPosition());
            averageBlendEqPart2.draw(*blendEqPart2, currentStates);
            currentStates.shader = nullptr;
            currentStates.blendMode=sf::BlendAdd;
            frameBuffer.draw(*blendEqPart1, currentStates);
            frameBuffer.draw(*blendEqPart2, currentStates);
            /*currentStates.blendMode = sf::BlendNone;
            currentStates.shader = &setAlphaShader;
            frameBuffer.draw(*alphaTile, currentStates);
            for (unsigned int i = 0; i < drawables.size(); i++) {
                frameBuffer.draw(drawables[i].first.get(), drawables[i].second);
            }*/
            averageBlendEqPart1.display();
            averageBlendEqPart2.display();
            depthBuffer.display();
            frameBuffer.display();
        }
        std::vector<Entity*> OITRenderComponent::getEntities() {
            return visibleEntities;
        }
        void OITRenderComponent::draw(Drawable& drawable, RenderStates states) {
            update = true;
            drawables.push_back(std::make_pair(std::ref(drawable), states));
        }
        void OITRenderComponent::draw(RenderTarget& target, RenderStates states) {
            frameBufferTile->setCenter(target.getView().getPosition());
            target.draw(*frameBufferTile, states);
            drawables.clear();
        }
 
        View& OITRenderComponent::getView() {
            return view;
        }
        int OITRenderComponent::getLayer() {
            return getPosition().z;
        }
        void OITRenderComponent::updateParticleSystems() {
            for (unsigned int i = 0; i < visibleEntities.size(); i++) {
                if (dynamic_cast<physic::ParticleSystem*>(visibleEntities[i]) != nullptr) {
                    static_cast<physic::ParticleSystem*>(visibleEntities[i])->update();
                }
            }
            loadEntitiesOnComponent(visibleEntities);
            update = true;
        }
    }
}
Mais là je sèche. :/ Lorsque je veux dessiner des sprites opaque, la couleur de mes sprites dans la texture averageBlendEqPart2 me donne des sprites semi-transparents hors qu'ils sont tous opaques donc il ne devrait pas y avoir de valeur < 1 pour alpha!!!

Pourquoi ça me donne des sprites semi-transparents hors que je n'en ai pas. Comment opengl arrive t'il à avoir des sprites semi-transparents ?

Ha oui et aussi j'ai du changer des pointeurs ne variable simple sinon ça ne s'affichait pas.