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.