Рендеринг прозрачных объектов

Я пытаюсь сделать стеклянную плоскость, регулируя прозрачность объекта альфа-значениями. В настоящее время это черная плоскость, поскольку мои альфа-значения не влияют на мои объекты. Пожалуйста, посмотрите на изображение:

glEnable(GL_BLEND); ничего не делает

а также

glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO); все мои объекты исчезают

фрагментный шейдер:

#version 330 core

// interpolated values from the vertex shaders
in vec3 vNormal;
in vec3 vPosition;
in vec2 vTexCoord;

// uniform input data
struct LightProperties
{
vec4 position;
vec4 ambient;
vec4 diffuse;
vec4 specular;
float shininess;
};

struct MaterialProperties
{
vec4 ambient;
vec4 diffuse;
vec4 specular;
};

uniform LightProperties uLightingProperties;
uniform MaterialProperties uMaterialProperties;
uniform vec3 uViewPoint;

uniform sampler2D uTextureSampler;

// uniform input data
uniform float uAlpha;

// output data
out vec4 fColor;

void main()
{
// calculate vectors for lighting
vec3 N = normalize(vNormal);
vec3 L;

// determine whether the light is a point light source or directional light
if(uLightingProperties.position.w == 0.0f)
L = normalize((uLightingProperties.position).xyz);
else
L = normalize((uLightingProperties.position).xyz - vPosition);

vec3 V = normalize(uViewPoint - vPosition);
vec3 R = reflect(-L, N);

vec3 colour = vec3(0.0f, 0.0f, 0.0f);

// calculate Phong lighting
vec4 ambient = uLightingProperties.ambient * uMaterialProperties.ambient;
vec4 diffuse = uLightingProperties.diffuse * uMaterialProperties.diffuse * max(dot(L, N), 0.0);
vec4 specular = vec4(0.0f, 0.0f, 0.0f, 1.0f);

if(dot(L, N) > 0.0f)
{
specular = uLightingProperties.specular * uMaterialProperties.specular
* pow(max(dot(V, R), 0.0), uLightingProperties.shininess);
}

// set output color
colour = (diffuse + specular + ambient).rgb;
colour *= texture(uTextureSampler, vTexCoord).rgb;
fColor = vec4(colour, uAlpha);
//fColor = texture(uTextureSampler, vTexCoord).rgb;
}

Это дает мне непрозрачную черную плоскость, когда я хочу полупрозрачную черную плоскость.

static void init(GLFWwindow* window)
{
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
//glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
//glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);

// read image data
g_texImage[0] = readBitmapRGBImage("images/check.bmp", &imageWidth[0], &imageHeight[0]);
g_texImage[1] = readBitmapRGBImage("images/smile.bmp", &imageWidth[1], &imageHeight[1]);
g_texImage[2] = readBitmapRGBImage("images/Fieldstone.bmp", &imageWidth[2], &imageHeight[2]);
g_texImage[3] = readBitmapRGBImage("images/sunflower.bmp", &imageWidth[3], &imageHeight[3]);
g_texImage[4] = readBitmapRGBImage("images/painting.bmp", &imageWidth[4], &imageHeight[4]);

// create and compile GLSL program from the shader files
g_shaderProgramID[0] = loadShaders("vertex_shaderL.vert", "fragment_shaderL.frag");
g_shaderProgramID[1] = loadShaders("vertex_shaderT.vert", "fragment_shaderT.frag");

// find the locations of shader variables
GLuint positionIndex[2];
positionIndex[0] = glGetAttribLocation(g_shaderProgramID[0], "aPosition");
GLuint normalIndex = glGetAttribLocation(g_shaderProgramID[0], "aNormal");
GLuint texCoordIndex = glGetAttribLocation(g_shaderProgramID[0], "aTexCoord");

g_MVP_Index = glGetUniformLocation(g_shaderProgramID[0], "uModelViewProjectionMatrix");
g_M_Index = glGetUniformLocation(g_shaderProgramID[0], "uModelMatrix");
g_viewPointIndex = glGetUniformLocation(g_shaderProgramID[0], "uViewPoint");
g_alphaIndex = glGetUniformLocation(g_shaderProgramID[0], "uAlpha");

g_texSampler_Index[0] = glGetUniformLocation(g_shaderProgramID[0], "uTextureSampler");

g_lightPositionIndex = glGetUniformLocation(g_shaderProgramID[0], "uLightingProperties.position");
g_lightAmbientIndex = glGetUniformLocation(g_shaderProgramID[0], "uLightingProperties.ambient");
g_lightDiffuseIndex = glGetUniformLocation(g_shaderProgramID[0], "uLightingProperties.diffuse");
g_lightSpecularIndex = glGetUniformLocation(g_shaderProgramID[0], "uLightingProperties.specular");
g_lightShininessIndex = glGetUniformLocation(g_shaderProgramID[0], "uLightingProperties.shininess");

g_materialAmbientIndex = glGetUniformLocation(g_shaderProgramID[0], "uMaterialProperties.ambient");
g_materialDiffuseIndex = glGetUniformLocation(g_shaderProgramID[0], "uMaterialProperties.diffuse");
g_materialSpecularIndex = glGetUniformLocation(g_shaderProgramID[0], "uMaterialProperties.specular");

positionIndex[1] = glGetAttribLocation(g_shaderProgramID[1], "aPosition");
g_texSampler_Index[1] = glGetUniformLocation(g_shaderProgramID[1], "uTextureSampler");
g_renderDepth_Index = glGetUniformLocation(g_shaderProgramID[1], "uRenderDepth");

// initialise model matrices
g_mm_floor = translate(vec3(0.2f, -4.0f, 0.0f));
g_mm_cube = translate(vec3(0.0f, -4.0f, 0.0f)) * scale(vec3(2.0f, 2.0f, 2.0f));
for (int i = 0; i < 4; i++)
{
g_mm_wall[i] = mat4(1.0f);
}
g_mm_painting[0] = mat4(1.0f);
g_mm_painting[1] = mat4(1.0f);
g_mm_glass = mat4(1.0f);
g_mm_torus = mat4(1.0f);

int width, height;
glfwGetFramebufferSize(window, &width, &height);
float aspectRatio = static_cast<float>(width) / height;

// camera
g_camera.setViewMatrix(vec3(0, 1, 10), vec3(0, 0, -10), vec3(0, 1, 0));
g_camera.setProjectionMatrix(perspective(45.0f, aspectRatio, 0.1f, 100.0f));

// initialise light and material properties
g_lightProperties.position = vec4(7.0f, 5.0f, 0.0f, 1.0f);
g_lightProperties.ambient = vec4(1.0f, 1.0f, 1.0f, 1.0f);
g_lightProperties.diffuse = vec4(1.0f, 1.0f, 1.0f, 1.0f);
g_lightProperties.specular = vec4(1.0f, 1.0f, 1.0f, 1.0f);
g_lightProperties.shininess = 10.0f;

g_materialProperties[0].ambient = vec4(0.3f, 0.3f, 0.3f, 1.0f);
g_materialProperties[0].diffuse = vec4(0.8f, 0.8f, 0.4f, 1.0f);
g_materialProperties[0].specular = vec4(0.8f, 0.8f, 0.4f, 1.0f);

g_materialProperties[1].ambient = vec4(0.3f, 0.3f, 0.3f, 1.0f);
g_materialProperties[1].diffuse = vec4(0.2f, 0.7f, 1.0f, 1.0f);
g_materialProperties[1].specular = vec4(0.2f, 0.7f, 1.0f, 1.0f);

g_materialProperties[2].ambient = vec4(0.3f, 0.3f, 0.3f, 1.0f);
g_materialProperties[2].diffuse = vec4(0.2f, 0.7f, 0.2f, 1.0f);
g_materialProperties[2].specular = vec4(0.2f, 0.7f, 0.2f, 1.0f);

// generate identifier for texture object and set texture properties
// checkered floor
glGenTextures(10, g_textureID);
glBindTexture(GL_TEXTURE_2D, g_textureID[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth[0], imageHeight[0], 0, GL_BGR, GL_UNSIGNED_BYTE, g_texImage[0]);
glGenerateMipmap(GL_TEXTURE_2D);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// smiley face
glBindTexture(GL_TEXTURE_2D, g_textureID[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth[1], imageHeight[1], 0, GL_BGR, GL_UNSIGNED_BYTE, g_texImage[1]);
glGenerateMipmap(GL_TEXTURE_2D);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// fieldstone wallpaper
glBindTexture(GL_TEXTURE_2D, g_textureID[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth[2], imageHeight[2], 0, GL_BGR, GL_UNSIGNED_BYTE, g_texImage[2]);
glGenerateMipmap(GL_TEXTURE_2D);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// sunflower painting
glBindTexture(GL_TEXTURE_2D, g_textureID[3]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth[3], imageHeight[3], 0, GL_BGR, GL_UNSIGNED_BYTE, g_texImage[3]);
glGenerateMipmap(GL_TEXTURE_2D);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// other painting
glBindTexture(GL_TEXTURE_2D, g_textureID[4]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth[4], imageHeight[4], 0, GL_BGR, GL_UNSIGNED_BYTE, g_texImage[4]);
glGenerateMipmap(GL_TEXTURE_2D);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// textures to be rendered to (i.e. render-to-texture)
glBindTexture(GL_TEXTURE_2D, g_textureID[6]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, g_windowWidth, g_windowHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

glBindTexture(GL_TEXTURE_2D, g_textureID[7]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, g_windowWidth, g_windowHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

// set up framebuffer object
glGenFramebuffers(1, &g_FBO);
glBindFramebuffer(GL_FRAMEBUFFER, g_FBO);

GLuint depthRenderBufferID;
glGenRenderbuffers(1, &depthRenderBufferID);
glBindRenderbuffer(GL_RENDERBUFFER, depthRenderBufferID);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, g_windowWidth, g_windowHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderBufferID);

// associate respective textures with framebuffer attachments
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, g_textureID[6], 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, g_textureID[7], 0);

// number of draw buffers
GLenum drawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, drawBuffers);

if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
exit(EXIT_FAILURE);

// generate identifier for VBOs and copy data to GPU
glGenBuffers(10, g_VBO);
glGenVertexArrays(10, g_VAO);

glBindBuffer(GL_ARRAY_BUFFER, g_VBO[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertices), g_vertices, GL_STATIC_DRAW);

glBindVertexArray(g_VAO[0]);
glBindBuffer(GL_ARRAY_BUFFER, g_VBO[0]);
glVertexAttribPointer(positionIndex[0], 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, position)));
glVertexAttribPointer(normalIndex, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, normal)));
glVertexAttribPointer(texCoordIndex, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, texCoord)));

glEnableVertexAttribArray(positionIndex[0]);
glEnableVertexAttribArray(normalIndex);
glEnableVertexAttribArray(texCoordIndex);

// to display the render-to-texture's texture on a screen space quad
glBindBuffer(GL_ARRAY_BUFFER, g_VBO[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_screenspaceQuad), g_screenspaceQuad, GL_STATIC_DRAW);

glBindVertexArray(g_VAO[1]);
glBindBuffer(GL_ARRAY_BUFFER, g_VBO[1]);
glVertexAttribPointer(positionIndex[1], 3, GL_FLOAT, GL_FALSE, 0, 0);

glEnableVertexAttribArray(positionIndex[1]);

// torus mesh
load_mesh("models/torus.obj", 0);
glBindBuffer(GL_ARRAY_BUFFER, g_VBO[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*g_numberOfVertices[0], g_pMeshVertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_VBO[3]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint) * 3 * g_numberOfFaces[0], g_pMeshIndices[0], GL_STATIC_DRAW);

glBindVertexArray(g_VAO[2]);
glBindBuffer(GL_ARRAY_BUFFER, g_VBO[2]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_VBO[3]);
glVertexAttribPointer(positionIndex[0], 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, position)));
glVertexAttribPointer(normalIndex, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, normal)));

glEnableVertexAttribArray(positionIndex[0]);
glEnableVertexAttribArray(normalIndex);
}

static void render_scene()
{
// draw to frame buffer object
glBindFramebuffer(GL_FRAMEBUFFER, g_FBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(g_shaderProgramID[0]);

glBindVertexArray(g_VAO[0]);

// set lighting properties
glUniform4fv(g_lightPositionIndex, 1, &g_lightProperties.position[0]);
glUniform4fv(g_lightAmbientIndex, 1, &g_lightProperties.ambient[0]);
glUniform4fv(g_lightDiffuseIndex, 1, &g_lightProperties.diffuse[0]);
glUniform4fv(g_lightSpecularIndex, 1, &g_lightProperties.specular[0]);
glUniform1fv(g_lightShininessIndex, 1, &g_lightProperties.shininess);

// set uniform shader variables
mat4 MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_glass;
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_glass[0][0]);
glUniform1f(g_alphaIndex, 0.5);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[0].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[0].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[0].specular[0]);

// draw glass
glDrawArrays(GL_TRIANGLES, 0, 6);

// set uniform shader variables
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_cube;
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_cube[0][0]);
glUniform1f(g_alphaIndex, 1.0);

glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[2].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[2].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[2].specular[0]);

// draw cube
glBindTexture(GL_TEXTURE_2D, g_textureID[1]);
glDrawArrays(GL_TRIANGLES, 6, 36);

// set uniform shader variables
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_floor;
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_floor[0][0]);
glUniform1f(g_alphaIndex, 1.0);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[0].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[0].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[0].specular[0]);

// draw floor
glBindTexture(GL_TEXTURE_2D, g_textureID[0]);
glDrawArrays(GL_TRIANGLES, 0, 6);

for (int i = 0; i < 3; i++)
{
// set uniform shader variables
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_wall[i];
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_wall[i][0][0]);
glUniform1f(g_alphaIndex, 1.0);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[1].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[1].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[1].specular[0]);

// draw walls
glBindTexture(GL_TEXTURE_2D, g_textureID[2]);
glDrawArrays(GL_TRIANGLES, 0, 6);
}

// set uniform shader variables
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_painting[0];
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_painting[0][0][0]);
glUniform1f(g_alphaIndex, 1.0);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[2].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[2].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[2].specular[0]);

// draw apples painting
glBindTexture(GL_TEXTURE_2D, g_textureID[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);

// set uniform shader variables
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_painting[1];
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_painting[1][0][0]);
glUniform1f(g_alphaIndex, 1.0);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[2].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[2].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[2].specular[0]);

// draw other painting
if (newpainting == false)
glBindTexture(GL_TEXTURE_2D, g_textureID[4]);
else
glBindTexture(GL_TEXTURE_2D, g_textureID[5]);
glDrawArrays(GL_TRIANGLES, 0, 6);

// set uniform shader variables
glBindVertexArray(g_VAO[2]);
MVP = g_camera.getProjectionMatrix() * g_camera.getViewMatrix() * g_mm_torus;
glUniformMatrix4fv(g_MVP_Index, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(g_M_Index, 1, GL_FALSE, &g_mm_torus[0][0]);
glUniform1f(g_alphaIndex, 1.0);

// set material properties
glUniform4fv(g_materialAmbientIndex, 1, &g_materialProperties[0].ambient[0]);
glUniform4fv(g_materialDiffuseIndex, 1, &g_materialProperties[0].diffuse[0]);
glUniform4fv(g_materialSpecularIndex, 1, &g_materialProperties[0].specular[0]);

// draw torus
glDrawElements(GL_TRIANGLES, g_numberOfFaces[0] * 3, GL_UNSIGNED_INT, 0);

// draw to normal display
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(g_shaderProgramID[1]);

glBindVertexArray(g_VAO[1]);

glUniform1i(g_texSampler_Index[1], 0);

// draw screenspace quad
glActiveTexture(GL_TEXTURE0);

if (g_bRenderDepth)
{
glUniform1i(g_renderDepth_Index, 1);
glBindTexture(GL_TEXTURE_2D, g_textureID[7]);
}
else
{
glUniform1i(g_renderDepth_Index, 0);
glBindTexture(GL_TEXTURE_2D, g_textureID[6]);
}

glDrawArrays(GL_TRIANGLES, 0, 6);

glFlush();
}