Discussion :

[Invité]

Salut, j'essaye de réaliser une démo-scene cependant j'ai un petit soucis de transparence, quand la texture est opaque pas de problème par contre lorsque je veux calculer l'opacité de la texture et l'appliquer, je me retrouve avec une texture noir et je ne parviens pas à trouvé pourquoi. :/

J'utilise du blending additif car je veux créer des points de lumière.

Voici le code :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <SDL2/SDL.h>
#include <stdio.h>
bool loadFromMemory (const char* vertexShaderCode, const char* fragmentShaderCode, unsigned int& shaderProgram) {
    //Program.
    shaderProgram = glCreateProgram();
    //Vertex shader.
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource (vertexShader, 1, &vertexShaderCode, NULL);
    glCompileShaderARB(vertexShader);
    GLint success;
    glGetObjectParameterivARB(vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &success);
    if (success == GL_FALSE)
    {
        char log[1024];
        glGetInfoLogARB(vertexShader, sizeof(log), 0, log);
        printf("Failed to compile vertex shader code : %s\n", log);
        glDeleteShader(vertexShader);
        glDeleteProgram(shaderProgram);
        shaderProgram = 0;
        return false;
    }
    glAttachShader(shaderProgram, vertexShader);
    glDeleteShader(vertexShader);
    //Fragment shader.
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSourceARB(fragmentShader, 1, &fragmentShaderCode, NULL);
    glCompileShaderARB(fragmentShader);
    glGetObjectParameterivARB(fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &success);
    if (success == GL_FALSE)
    {
        char log[1024];
        glGetInfoLogARB(fragmentShader, sizeof(log), 0, log);
        printf("Failed to compile fragment shader code : %s\n", log);
        glDeleteShader(fragmentShader);
        glDeleteShader(shaderProgram);
        shaderProgram = 0;
        return false;
    }
    glAttachShader(shaderProgram, fragmentShader);
    glDeleteShader(fragmentShader);
    //Linkage.
    glLinkProgram(shaderProgram);
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (success == GL_FALSE)
    {
        char log[1024];
        glGetInfoLogARB(fragmentShader, sizeof(log), 0, log);
        printf("Failed to link shader program : %s\n", log);
        glDeleteShader(shaderProgram);
        shaderProgram = 0;
        return false;
    }
    glFlush();
    return true;
}
void setParameter (unsigned int shaderProgram, const char* name, float x, float y) {
    glUseProgram(shaderProgram);
    GLint location = glGetUniformLocation(shaderProgram, name);
    glUniform2f(location, x, y);
}
bool createTexture (unsigned int width, unsigned int height, const char* pixels, unsigned int& texture) {
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    if (texture)
        return true;
    return false;
}
int main(int argc, char** argv) {
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
        fprintf(stdout,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
        return -1;
    }
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("test SDL2/Opengl", 0, 0, 800, 600,
                                          SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
 
    SDL_GLContext glcontext = SDL_GL_CreateContext(window);
    GLenum err = glewInit();
    if (err == GL_TRUE) {
        printf("Failed to initialize glew!");
    }
    bool terminated = false;
    glMatrixMode(GL_PROJECTION);
    gluPerspective(80, 800/600, 1, 1000);
    glMatrixMode(GL_MODELVIEW);
    gluLookAt(0, 0, 0, 0, 1, 0, 0, 0, 1);
    int texSize = 5;
    glPointSize(texSize);
    const char* vertexShaderCode =
    "#version 130 \n"
    "void main() {"
    "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
    "   gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;"
    "   gl_FrontColor = gl_Color;"
    "}";
    const char* fragmentShaderCode =
    "#version 130 \n"
    "const ivec2 resolution = ivec2 (800, 600);"
    "uniform sampler2D tex;"
    "void main() {"
    "   vec4 texel = texture(tex, gl_TexCoord[0].xy);"
    "   gl_FragColor = gl_Color * texel;"
    "}";
    GLuint shaderProgram = 0;
    if(!loadFromMemory(vertexShaderCode, fragmentShaderCode, shaderProgram)) {
        printf("failed to load shader program!");
        exit(-1);
    }
    char pixels[800*600*4];
    float halfTexSize = texSize * 0.5f;
    for (unsigned int j = 0; j < 600; j++) {
        for (unsigned int i = 0; i < 800; i++) {
            if (i < texSize && j < texSize) {
                pixels[(j*800+i)*4] = 255;
                pixels[(j*800+i)*4+1] = 255;
                pixels[(j*800+i)*4+2] = 0;
                float attenuation = sqrt((i-halfTexSize)*(i-halfTexSize)+(j-halfTexSize)*(j-halfTexSize)) / texSize;
                pixels[(j*800+i)*4+2] = 255 * attenuation;
            } else {
                pixels[(j*800+i)*4] = 0;
                pixels[(j*800+i)*4+1] = 0;
                pixels[(j*800+i)*4+2] = 0;
                pixels[(j*800+i)*4+3] = 0;
            }
        }
    }
    unsigned int texture;
    createTexture(800, 600, pixels, texture);
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE);
    glUseProgram(shaderProgram);
    while (!terminated) {
        glClearColor(0, 0, 0, 1);
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
        glColor3f(1, 1, 0);
        for (int x = -10; x <= 10; ++x) {
            for (int y = -10; y <= 10; ++y) {
                glTexCoord2f(0, 0);
                glVertex3i(x, y, 1);
            }
        }
        glEnd();
        SDL_GL_SwapWindow(window);
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            if (event.window.event == SDL_WINDOWEVENT_CLOSE)
                terminated = true;
        }
    }
    SDL_GL_DeleteContext(glcontext);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

Merci d'avance pour votre aide.

[ternel]

google(opengl blending): premier résultat, premiere ligne de code:
https://www.opengl.org/archives/reso...ansparency.htm

An OpenGL application typically enables blending as follows:

glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Or, toi, tu as écris glBlendFunc (GL_SRC_ALPHA, GL_ONE);. Es-tu certain de ton choix?

[Invité]

Ok j'ai trouvé mon erreur, elle était ici :

Code cpp :

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

1
2
3
 
float attenuation = sqrt((i-halfTexSize)*(i-halfTexSize)+(j-halfTexSize)*(j-halfTexSize)) / texSize;
pixels[(j*800+i)*4+3] = 255 * attenuation;

+3 et non +2!

Ceci dit que j'essaye l'un ou l'autre, pour le blending, mes points sont toujours de la même couleur partout hors moi je veux que ça soit plus transparent sur les bords, donc plus on s'éloigne du centre du point, plus c'est transparent.

Mais, peut on appliquer différente couleurs pour un même fragment afin de faire une sorte de dégradé sur les bords ?

Je pense que non alors c'est pour cela que j'ai voulu plaquer une texture sur mes points mais ça ne rend pas comme je l'espérais. :/

[Invité]

Bon..., openGL n'envoie qu'une seule coordonnée de texture par point et donc par fragment, mais ma question c'est combien de fois on passe dans la fragment shader par point ?

glFragCoord c'est toujours la position du centre du point qu'elle vaut ou bien la position de tout les pixels du point ?

[ternel]

Code :

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

pixels[(j*800+i)*4+3] = 255 * attenuation;

Dans cette ligne, je vois quatre fautes.

Personnellement, je râle systématiquement sur les nombres magiques.
4 nombres magiques = 4 fautes encore pires que des variables globales.

Ton code n'est pas lisible, et devrait être écrit ainsi:

Code :

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

pixels[(j*row_length+i)*composantes_per_pixels+alpha_composante] = attenuation_scaling * attenuation;

Qui plus est, vue la formule de attenuation, j'aurais utilisé 256 plutot que 255, car attenuation_scaling ne devrait jamais valoir exactement 1.


Cela dit, dans ton code de base, la focntion create_texture() se termine ainsi:

Code :

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

1
2
3
4
5
//...
    if (texture)
        return true;
    return false;
}

ca s'écrit aussi bien
return (texture) ? true : false;, c'est à dire return texture;.
Et comme texture est un pointeur, j'écrirai même: return texture!=0; ou return texture != std::nullptr;.

[Invité]

Ok, j'ai modifier mon code et je pense avoir trouvé une solution, en utilisant la même technique que le shadow mapping c'est à dire en essayant de mapper les coordonnées des pixels de mes points entre 0 et 1 en utilisant l'interpolation hardware.

Ce qui me donne ceci au niveau du code pour mes shaders.

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
const char* vertexShaderCode =
    "#version 130 \n"
    "const mat4 biasMatrix;"
    "biasMatrix[0] = vec4 (0.5, 0.0, 0.0, 0.0);"
    "biasMatrix[1] = vec4 (0.0, 0.5, 0.0, 0.0);"
    "biasMatrix[2] = vec4 (0.0, 0.0, 0.5, 0.0);"
    "biasMatrix[3] = vec4 (0.5, 0.5, 0.5, 1.0);"
    "out vec4 centerPoint;"
    "void main() {"
    "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
    "   gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;"
    "   gl_FrontColor = gl_Color;"
    "   centerPoint = biasMatrix * gl_ModelViewProjectionMatrix * gl_Position;"
    "}";
    const char* fragmentShaderCode =
    "#version 130 \n"
    "in vec4 centerPoint;"
    "uniform sampler2D tex;"
    "void main() {"
    "   vec2 centerTex = gl_TexCoord[0].xy;"
    "   vec2 centerTexToFrag = vec2(centerPoint.xy) - centerTex;"
    "   float attenuation = length(centerTexToFrag) / 5;"
    "   gl_FragColor = gl_Color * attenuation;"
    "}";

Malheureusement ça ne compile pas, voici l'erreur retournée :

Code :

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

1
2
 
Failed to compile vertex shader code : 0:2(23): error: Syntaxe error, unexpected NEW_IDENTIFIER, expecting $end.

Le problème surviens lors de l'initialisation de la matrice. :/

[bacelar]

Si vos "points" ont une épaisseur, pourquoi ne pas faire du billboarding avec des textures à channel alpha ???
http://ogldev.atspace.co.uk/www/tuto...utorial27.html
http://ogldev.atspace.co.uk/www/tuto...utorial28.html

[Invité]

Je ne possède pas de geometry shader. :/

J'ai essayé d'activer GL_POINTS_SMOOTH pour avoir des points rond et pas carré mais ça ne fonctionne pas.

J'ai également tenté d'activier l'anti-alisiasing pour avoir un effet de dégradé mais ça ne fonctionne pas non plus.

Là encore une fois je pense que le problème vient du driver. :/

Il faudra vraiment que j'essaye de me débrouiller avec openCL un jour...

[RedSkidy]

je crois qu'on peut en faire sans geometry shader

[dragonjoker59]

Sinon, pour ton erreur d'initialisation de ta matrice:
const mat4 biasMatrix;Puis:

Code :

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

1
2
3
4
biasMatrix[0] = vec4 (0.5, 0.0, 0.0, 0.0);
biasMatrix[1] = vec4 (0.0, 0.5, 0.0, 0.0);
biasMatrix[2] = vec4 (0.0, 0.0, 0.5, 0.0);
biasMatrix[3] = vec4 (0.5, 0.5, 0.5, 1.0);

Je ne sais pas en GLSL, mais en C++: "Ca ne marchera jamais!" changer la valeur d'une variable declaree const...