[OpenGL] Shader lent.

Salut, j'essaye d'effecture du multi-pass rendering à l'aide de shaders et de texture mais c'est assez lent, bref, voici le code source de mes "fragment shaders" :

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
 
 const std::string depthGenFragShader =
        "uniform sampler2D depthBuffer;"
        "uniform sampler2D texture;"
        "uniform vec3 resolution;"
        "void main () {"
              "vec2 position = ( gl_FragCoord.xy / resolution.xy );"
              "vec4 color = texture2D(depthBuffer, position);"
              "vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);"
              "if (gl_FragCoord.z >= color.z && pixel.a >= color.a) {"
                 "gl_FragColor = vec4(0, 0,gl_FragCoord.z, pixel.a);"
              "} else {"
                 "gl_FragColor = color;"
              "}"
        "}";
        const std::string frameBufferGenFragShader =
        "uniform sampler2D depthBuffer;"
        "uniform sampler2D frameBuffer;"
        "uniform sampler2D texture;"
        "uniform vec3 resolution;"
        "void main () {	"
            "vec2 position = ( gl_FragCoord.xy / resolution.xy );"
            "vec4 depth = texture2D(depthBuffer, position);"
            "vec4 color = texture2D(frameBuffer, position);"
            "vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);"
            "if (gl_FragCoord.z > depth.z) {"
                "gl_FragColor = pixel;"
            "} else if (color.a < pixel.a) {"
                "gl_FragColor = pixel;"
            "} else {"
                "gl_FragColor = color;"
            "}"
        "}";

Sinon j'ai tout optimisé là ou je pouvais : rendu VBO en prétransformant les entités dynamique pour update leur position dans leur vbo, j'ai aussi regroupé tout les tableau de sommets utilisant la même texture ensemble pour éviter de devoir faire trop d'appels à glBind, etc...

Et sans le shader mon rendu est rapide donc...

Bonjour,

Il ne me semble pas y avoir de chose choquante dans votre shader, donc, je doute que ce soit le shader en lui même qui soit problématique. Après, cela dépend aussi un peu de la carte graphique.

Comme carte graphique j'ai une ATI mobility radeon HD 5470. (512 MB)

Je pense que ce qui ralenti beaucoup le code source c'est lorsque je passe mes textures à mes shaders :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 if (Shader::isAvailable()) {
        for (unsigned int i = 0; i < m_vertices.size(); i++) {
            currentStates.texture = m_vertices[i].first.getMaterial().getTexture();
            for (unsigned int j = 0; j < m_vertices[i].second.size(); j++) {
                currentStates.shader = frameBufferGenerator;
                frameBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
                frameBufferGenerator->setParameter("frameBuffer", frameBuffer->getTexture());
                frameBufferGenerator->setParameter("texture", Shader::CurrentTexture);
                frameBuffer->draw(*m_vertices[i].second[j], currentStates);
                frameBuffer->display();
                depthBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
                depthBufferGenerator->setParameter("texture", Shader::CurrentTexture);
                currentStates.shader = depthBufferGenerator;
                depthBuffer->draw(*m_vertices[i].second[j], currentStates);
                depthBuffer->display();
            }
        }
    }

Bref n'y a t'il vraiment pas un moyen de créer une référence vers les textures dans le shader plutôt que de devoir passer à chaque fois les textures au shader une fois que l'on remet à jour la texture ???

Sinon je suis sous ubuntu 64 bits et j'utilise bien sûr les driver opensource. (les drivers propriétaires ne fonctionnent pas)

Euh, pourquoi vous passer vos textures à chaque sommets ?

Code:

1
2
3
or (unsigned int j = 0; j < m_vertices[i].second.size(); j++) {
                currentStates.shader = frameBufferGenerator;
                frameBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());

Bref je pense que le problème doit venir d'ailleurs, mais c'est sur que ça provient du dessin des entités sur mes composants car quand je dessine directement les entités sur la fenêtre c'est beaucoup moins lent.

Voici les 2 classes que j'utilise pour dessiner sur mes composants :

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
 
#include "../../../../include/odfaeg/Graphics/2D/fastRenderComponent.h"
using namespace sf;
namespace odfaeg {
namespace g2d {
FastRenderComponent::FastRenderComponent (RenderWindow& window, int layer) :
    Transformable(Vec3f(window.getView().getPosition().x, window.getView().getPosition().y, layer),
                  Vec3f(window.getView().getSize().x, window.getView().getSize().y, 0),
                  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()) {
    sf::Vector3i resolution ((int) window.getSize().x, (int) window.getSize().y, window.getView().getSize().z);
    depthBuffer = new RenderTexture();
    frameBuffer = new RenderTexture();
    depthBuffer->create(resolution.x, resolution.y);
    frameBuffer->create(resolution.x, resolution.y);
    frameBuffer->setView(window.getView());
    depthBuffer->setView(window.getView());
    frameBuffer->clear(sf::Color::Transparent);
    depthBuffer->clear(sf::Color::Transparent);
    frameBufferTile = new Tile(&frameBuffer->getTexture(), Vec2f(0, 0), Vec2f(window.getView().getSize().x, window.getView().getSize().y), IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
    depthBufferTile = new Tile(&depthBuffer->getTexture(), Vec2f(0, 0), Vec2f(window.getView().getSize().x, window.getView().getSize().y), IntRect(0, 0, window.getView().getSize().x, window.getView().getSize().y));
    if (Shader::isAvailable()) {
        frameBufferGenerator = new Shader();
        depthBufferGenerator = new Shader();
        /*std::string vertexShader;
        //With modern openg, we need to use another vertex shader.
        //GLSL 3 is not supported by all the drivers so we use GLSL 1.
        if (window.getSettings().majorVersion >= 3) {
            vertexShader =
            "attribute vec3 vertex_position;"
            "attribute vec4 vertex_color;"
            "attribute vec2 vertex_texCoord0;"
            "void main () {"
                "vec4 vPos = vec4(vertex_position, 1.0);"
                "vec4 vTexCoord0 = vec4 (vertex_texCoord0, 0, 0);"
                "gl_Position = gl_ModelViewProjectionMatrix * vPos;"
                "gl_TexCoord[0] = gl_TextureMatrix[0] * vTexCoord0;"
                "gl_FrontColor = vertex_color;"
            "}";
        } else {*/
         const std::string   vertexShader =
            "void main () {"
                "gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
                "gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;"
                "gl_FrontColor = gl_Color;"
            "}";
        //}
        const std::string depthGenFragShader =
        "uniform sampler2D depthBuffer;"
        "uniform sampler2D texture;"
        "uniform vec3 resolution;"
        "void main () {"
              "vec2 position = ( gl_FragCoord.xy / resolution.xy );"
              "vec4 color = texture2D(depthBuffer, position);"
              "vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);"
              "if (gl_FragCoord.z >= color.z && pixel.a >= color.a) {"
                 "gl_FragColor = vec4(0, 0,gl_FragCoord.z, pixel.a);"
              "} else {"
                 "gl_FragColor = color;"
              "}"
        "}";
        const std::string frameBufferGenFragShader =
        "uniform sampler2D depthBuffer;"
        "uniform sampler2D frameBuffer;"
        "uniform sampler2D texture;"
        "uniform vec3 resolution;"
        "void main () {	"
            "vec2 position = ( gl_FragCoord.xy / resolution.xy );"
            "vec4 depth = texture2D(depthBuffer, position);"
            "vec4 color = texture2D(frameBuffer, position);"
            "vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);"
            "if (gl_FragCoord.z > depth.z) {"
                "gl_FragColor = pixel;"
            "} else if (color.a < pixel.a) {"
                "gl_FragColor = pixel;"
            "} else {"
                "gl_FragColor = color;"
            "}"
        "}";
        if (!depthBufferGenerator->loadFromMemory(vertexShader, depthGenFragShader))
            throw Erreur(50, "Failed to load depth buffer generator shader", 0);
        if (!frameBufferGenerator->loadFromMemory(vertexShader, frameBufferGenFragShader))
            throw Erreur(51, "Failed to load frame buffer generator shader", 0);
        /*if (window.getSettings().majorVersion >= 3) {
            frameBufferGenerator->bindAttribute(0, "vertex_position");
            depthBufferGenerator->bindAttribute(0, "vertex_position");
            frameBufferGenerator->bindAttribute(1, "vertex_color");
            depthBufferGenerator->bindAttribute(1, "vertex_color");
            frameBufferGenerator->bindAttribute(2, "vertex_texCoord0");
            depthBufferGenerator->bindAttribute(2, "vertex_texCoord0");
 
        }*/
        depthBufferGenerator->setParameter("resolution",resolution.x, resolution.y, resolution.z);
        frameBufferGenerator->setParameter("resolution",resolution.x, resolution.y, resolution.z);
        frameBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
        frameBufferGenerator->setParameter("frameBuffer", frameBuffer->getTexture());
        frameBufferGenerator->setParameter("texture", Shader::CurrentTexture);
        depthBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
        depthBufferGenerator->setParameter("texture", Shader::CurrentTexture);
        backgroundColor = sf::Color::Transparent;
        running = updateDepthBuffer = false;
        g_notified = true;
 
    }
    currentStates.blendMode = sf::BlendAlpha;
}
void FastRenderComponent::setBackgroundColor(sf::Color color) {
    this->backgroundColor = color;
}
void FastRenderComponent::clearBufferBits() {
     frameBuffer->clear(backgroundColor);
}
void FastRenderComponent::clearDepthBits() {
     depthBuffer->clear(sf::Color::Transparent);
}
g2d::Tile& FastRenderComponent::getFrameBufferTile () {
    return *frameBufferTile;
}
g2d::Tile& FastRenderComponent::getDepthBufferTile() {
    return *depthBufferTile;
}
bool FastRenderComponent::loadEntitiesOnComponent(std::vector<Entity*> vEntities)
{
 
    if (Shader::isAvailable()) {
        fg.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++) {
 
                    vEntities[i]->getFaces()[j]->transform(vEntities[i]->getTransform());
 
                    fg.addFace(vEntities[i]->getFaces()[j]);
                }
            }
        }
        m_vertices = fg.getFaces();
    }
    this->visibleEntities = vEntities;
}
void FastRenderComponent::setView(View &view) {
    this->view = view;
    frameBuffer->setView(view);
    depthBuffer->setView(view);
}
 
void FastRenderComponent::drawNextFrame() {
    if (Shader::isAvailable()) {
        for (unsigned int i = 0; i < m_vertices.size(); i++) {
            currentStates.texture = m_vertices[i].first.getMaterial().getTexture();
            for (unsigned int j = 0; j < m_vertices[i].second.size(); j++) {
                currentStates.shader = frameBufferGenerator;
                /*frameBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
                frameBufferGenerator->setParameter("frameBuffer", frameBuffer->getTexture());
                frameBufferGenerator->setParameter("texture", Shader::CurrentTexture);*/
                frameBuffer->draw(*m_vertices[i].second[j], currentStates);
                frameBuffer->display();
                /*depthBufferGenerator->setParameter("depthBuffer", depthBuffer->getTexture());
                depthBufferGenerator->setParameter("texture", Shader::CurrentTexture);*/
                currentStates.shader = depthBufferGenerator;
                depthBuffer->draw(*m_vertices[i].second[j], currentStates);
                depthBuffer->display();
            }
        }
    } else {
        for (unsigned int i = 0; i < visibleEntities.size(); i++) {
            for (unsigned int j = 0; j < visibleEntities[i]->getFaces().size(); j++) {
                currentStates.texture = visibleEntities[i]->getFaces()[j]->getMaterial().getTexture();
                currentStates.transform = visibleEntities[i]->getTransform();
                frameBuffer->draw(visibleEntities[i]->getFaces()[j]->getVertexArray(), currentStates);
            }
        }
    }
 
}
void FastRenderComponent::draw(RenderTarget& target, RenderStates states) const {
 
    const_cast<FastRenderComponent*>(this)->frameBufferTile->setCenter(frameBuffer->getView().getPosition());
    states.transform = getTransform();
    target.draw(*frameBufferTile, states);
}
void FastRenderComponent::init() {
}
 
View& FastRenderComponent::getView() {
    return view;
}
int FastRenderComponent::getLayer() {
    return getPosition().z;
}
FastRenderComponent::~FastRenderComponent() {
    running = false;
    delete frameBuffer;
    delete frameBufferGenerator;
    delete depthBuffer;
    delete depthBufferGenerator;
    delete frameBufferTile;
    delete depthBufferTile;
}
}
}

Je compte aussi plus tard me servir du framebuffer et du depthbuffer pour les lumières et les ombres en projetant un rayon qui va de la caméra jusqu'au fragment puis du fragment vers la lumière. (faire un genre de système de raytracing)

Bref voici mon autre classe, celle ou je défini toute les faces de mes objets 2D et 3D ainsi que mes matériaux, et ou je regroupe tout les tableau de sommets utilisant les même matériaux afin de les passer au shader lorsque je dessine les entités sur mes composants :

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
 
#ifndef ODFAEG_FACE_HPP
#define ODFAEG_FACE_HPP
#include "vertexArray.h"
#include <map>
namespace odfaeg {
class ODFAEG_GRAPHICS_API Material {
     private :
     struct TextureInfo {
        private :
        const Texture* texture;
        sf::IntRect rect;
        std::string texId;
        public :
        TextureInfo (const Texture* texture, sf::IntRect rect, std::string texId="") {
            this->texture = texture;
            this->rect = rect;
            this->texId = texId;
        }
        void setTexId(std::string texId) {
            this->texId = texId;
        }
        std::string getTexId() {
            return texId;
        }
        bool operator== (TextureInfo& info) {
            return texture == info.texture;
        }
        bool operator!= (TextureInfo& info) {
            return texture != info.texture;
        }
        const Texture* getTexture() const {
            return texture;
        }
        sf::IntRect getTexRect() {
            return rect;
        }
    };
    std::vector<TextureInfo*> texInfos;
    sf::Color color;
    public :
    int getNbTextures () {
        return texInfos.size();
    }
    void addTexture (const Texture* texture, sf::IntRect rect) {
        texInfos.push_back(new TextureInfo(texture, rect));
    }
    sf::IntRect getTexRect(int texUnit = 0) {
        return (texInfos.size() > 0) ? texInfos[texUnit]->getTexRect() : sf::IntRect(0, 0, 0, 0);
    }
    const Texture* getTexture(int texUnit = 0) {
        return (texInfos.size() > 0) ? texInfos[texUnit]->getTexture() : nullptr;
    }
    std::string getTexId(int texUnit = 0) {
        return (texInfos.size() > 0) ? texInfos[texUnit]->getTexId() : nullptr;
    }
    void setTexId(std::string texId, int texUnit = 0) {
        if (texInfos.size() > 0) {
            texInfos[texUnit]->setTexId(texId);
        }
    }
    bool useSameTextures (Material material) {
        if (texInfos.size() != material.texInfos.size())
            return false;
        for (unsigned int i = 0; i < texInfos.size(); i++) {
            if (*texInfos[i] != *material.texInfos[i])
                return false;
        }
        return true;
 
    }
    bool hasSameColor (Material& material) {
        return color == material.color;
    }
    bool operator== (Material material) {
        return useSameTextures(material) && hasSameColor(material);
    }
    bool operator!= (Material material) {
        return !useSameTextures(material) || !hasSameColor(material);
    }
 
};
class ODFAEG_GRAPHICS_API Face  {
public :
    Face(sf::PrimitiveType primType) {
        transformed = false;
        m_vertices.setPrimitiveType(primType);
    }
    void transform(TransformMatrix tm) {
        if (!transformed) {
            for (unsigned int i = 0; i < m_vertices.getVertexCount(); i++) {
                Vec3f localPos (m_vertices.getLocal(i).x, m_vertices.getLocal(i).y, m_vertices.getLocal(i).z);
                Vec3f finalPos = tm.transform(localPos);
                m_vertices[i].position = sf::Vector3f(finalPos.x, finalPos.y, finalPos.z);
            }
            if (VBO::isAvailable())
                m_vertices.updateVBOBuffer();
            transformed = true;
        }
    }
    void append(Vertex vertex) {
        m_vertices.append(vertex);
    }
    Material& getMaterial() {
        return m_material;
    }
    VertexArray& getVertexArray() {
        return m_vertices;
    }
    bool useSameMaterial(Face& other) {
        return m_material == other.m_material;
 
    }
    bool useSamePrimType (Face &other) {
        return m_vertices.getPrimitiveType() == other.m_vertices.getPrimitiveType();
    }
    void updateTransform() {
        transformed = false;
    }
private :
    bool transformed;
    VertexArray m_vertices;
    Material m_material;
};
 
class ODFAEG_GRAPHICS_API FaceGroup {
    public :
    class BufferType {
    public:
        BufferType(Material material, sf::PrimitiveType pType) {
            this->material = material;
            primType = pType;
        }
        Material& getMaterial() {
            return material;
        }
        sf::PrimitiveType getPrimitiveType() {
            return primType;
        }
    private:
        Material material;
        sf::PrimitiveType primType;
    };
    void addFace(Face* face) {
        bool added = false;
        for (unsigned int i = 0; i < faces.size() && !added; i++) {
            if (faces[i].first.getMaterial() == face->getMaterial()
                && faces[i].first.getPrimitiveType() == face->getVertexArray().getPrimitiveType()) {
                    added = true;
                    faces[i].second.push_back(&face->getVertexArray());
                    /*for (unsigned int k = 0; k < face->getVertexArray().getVertexCount(); k++)
                        if(face->getVertexArray()[k].position.x == 0 && face->getVertexArray()[k].position.y == 130) {
                            std::cout<<face->getVertexArray()[k].position.z<<std::endl;
                            //face->getVertexArray()[k].position.z = 0;
                        }*/
            }
        }
        if (!added) {
            std::pair<BufferType, std::vector<VertexArray*>> f (BufferType(face->getMaterial(), face->getVertexArray().getPrimitiveType()), std::vector<VertexArray*> ());
            faces.push_back(f);
            faces.back().second.push_back(&face->getVertexArray());
        }
    }
    std::vector<std::pair<BufferType, std::vector<VertexArray*>>> getFaces() {
        return faces;
    }
    void clear() {
        for (unsigned int i = 0; i < faces.size(); i++) {
            faces[i].second.clear();
        }
    }
private :
    std::vector<std::pair<BufferType, std::vector<VertexArray*>>> faces;
};
}
#endif // FACE_HPP

Le problème doit sûrement venir d'une de ces 2 classes là...

Je crois que chez AMD, un truc perf killer était la non utilisation des textures de taille en puissance de 2. Donc, pour vos FBO, je vous conseille d'utiliser des tailles genre 1024x1024 ou 2048x2048.

Le problème venait d'ailleurs en fait il venait de ma boucle d'événements. (en fait je passais les événements un par un à mon thread au lieu de passer tout les événements qui ont été généré depuis la dernière boucle du coup ça ralentissais l'api)