OpenGL not drawing in Linux [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 4 years ago.
Improve this question
I have been trying to fix this for days, but haven't come anywhere other then replacing sfml with glfw.
I tried using sfml first with OpenGL, but it didn't draw. That's why I tried using glfw instead.
There is no errors from the glsl files nor the main.cpp file.
This code (but less modified, because of replacing sfml with glfw) actually works on my other Windows PC.
Now I'm using Linux because my other PC needs a motherboard replacement.
Changing the color of the "background" works with glClearColor but drawing doesn't.
This program is supposed to have a cube that rotates and have textures.
I'm actually learning OpenGL atm.
I compiled and ran the program within the terminal instead of codeblocks.
Not that it would really help but just giving out the info.
Thank you for any help :)
main file
#include <GL/glew.h>
#include <glfw3.h>
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <chrono>
#include <SOIL.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
void bindBufferData(GLfloat* vertices, GLuint& vbo);
GLuint createShaderProgam(const GLchar* vertexShaderText, const
GLchar* fragmentShaderText);
std::string loadFileContent(const std::string filepath);
static void glfwerror(int id, const char* description);
int main()
{
int width = 600, height = 600;
if(!glfwInit())
{
std::cout << "Initialization failed" << std::endl;
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_DOUBLEBUFFER, 1);
glfwWindowHint(GLFW_DEPTH_BITS, 24);
glfwSetErrorCallback(&glfwerror);
GLFWwindow* window = glfwCreateWindow(width, height, "OpenGL",
NULL, NULL);
if(!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glewExperimental = true;
if (glewInit() != GLEW_OK)
{
std::cout << "failed to initialize: " <<
glewGetErrorString(glewInit()) << std::endl;
}
std::cout << "OpenGL ver: " << glGetString(GL_VERSION) <<
std::endl;
std::cout << "GLSL ver: " <<
glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
float vertices[] = {
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
std::string vertexShaderText =
loadFileContent("shader.vert.glsl");
std::string fragmentShaderText =
loadFileContent("shader.frag.glsl");
GLuint shaderProgram =
createShaderProgam(vertexShaderText.c_str(),
fragmentShaderText.c_str());
glUseProgram(shaderProgram);
GLuint ebo;
GLuint vbo;
GLuint vao;
GLuint tex;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
GL_STATIC_DRAW);
glGenBuffers(1, &ebo);
GLuint elements[]{
0, 1, 2,
2, 3, 0
};
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements,
GL_STATIC_DRAW);
glEnableClientState(GL_VERTEX_ARRAY);
glGenVertexArrays(0, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float),
(GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float),
(GLvoid*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
GLint texAttrib = glGetAttribLocation(shaderProgram, "texcoord");
glEnableVertexAttribArray(texAttrib);
glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 8 *
sizeof(float), (GLvoid*)(6 * sizeof(float)));
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
int S_width, S_height;
unsigned char* image = SOIL_load_image("unity_preview_02-.jpeg",
&S_width, &S_height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, S_width, S_height, 0,
GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
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_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glm::mat4 view = glm::lookAt(
glm::vec3(2.2f, 2.2f, 1.5f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 0.0f, 1.0f)
);
GLint uniView = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
glm::mat4 proj = glm::perspective(glm::radians(45.0f), 800.0f /
600.0f, 1.0f, 20.0f);
GLuint uniProj = glGetUniformLocation(shaderProgram, "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
glm::mat4 transf = glm::mat4(1.0f);
GLint unitransf = glGetUniformLocation(shaderProgram, "transf");
glEnable(GL_DEPTH_TEST);
glm::vec4 resultRot = transf * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
printf("%f, %f, %f\n", resultRot.x, resultRot.y, resultRot.z);
auto t_start = std::chrono::high_resolution_clock::now();
GLfloat angle = -60.0f;
GLfloat speed = 0.0f;
GLfloat y = 0.5f;
GLfloat x = 0.5f;
GLfloat z = 1.5f;
while(!glfwWindowShouldClose(window))
{
glLoadIdentity();
glClearColor(0.0f, 1.0f, 0.7f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Setup view
float Ratio;
glfwGetFramebufferSize(window, &width, &height);
Ratio = width / (float)height;
glViewport(0, 0, width, height);
auto t_now = std::chrono::high_resolution_clock::now();
float time =
std::chrono::duration_cast<std::chrono::duration<float>>(t_now
- t_start).count();
t_start = t_now;
transf = glm::rotate(transf, time * glm::radians(angle),
glm::vec3(x, y, z));
glUniformMatrix4fv(unitransf, 1, GL_FALSE,
glm::value_ptr(transf));
z += 10 * time;
x += 5 * time;
y -= 5 * time;
//std::cout << x << ", " << y << ", " << z << std::endl;
glColor4f(1.0f, 0.0f, 1.0f, 1.0f);
glDrawArrays(GL_TRIANGLES, 0, 36);
//swap buffer and check for events
glfwSwapBuffers(window);
glfwPollEvents();
}
//sf::sleep(sf::milliseconds(2));
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
static void glfwerror(int id, const char* description)
{
std::cout << description << std::endl;
}
void bindBufferData(GLfloat* vertices, GLuint& vbo)
{
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
GLuint createShaderProgam(const GLchar* vertexShaderText, const
GLchar* fragmentShaderText)
{
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
GLuint shaderProgram = glCreateProgram();
glShaderSource(vertexShader, 1, &vertexShaderText, nullptr);
glCompileShader(vertexShader);
GLint succes;
GLchar infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &succes);
if(!succes)
{
glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
std::cout << "failed to compile vertex shader: " << infoLog <<
std::endl;
}
glShaderSource(fragmentShader, 1, &fragmentShaderText, nullptr);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &succes);
if (!succes)
{
glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);
std::cout << "failed to compile fragment shader: " << infoLog
<< std::endl;
}
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &succes);
if(!succes)
{
glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
std::cout << "failed to link program: " << infoLog <<
std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return shaderProgram;
}
std::string loadFileContent(const std::string filepath)
{
std::ifstream file(filepath);
std::stringstream sstream;
if(!file.is_open())
{
std::cout << "could not find file: " << filepath << std::endl;
}
sstream << file.rdbuf();
return sstream.str();
}
fragment shader
#version 450 core
in vec3 vertexColor;
in vec2 Texcoord;
out vec4 outcolor;
uniform sampler2D tex;
void main()
{
outcolor = texture(tex, Texcoord) * vec4(vertexColor, 1.0);
}
vertex shader
#version 450 core
layout (location = 0)
in vec3 pos;
layout (location = 1)
in vec3 col;
in vec2 texcoord;
out vec3 vertexColor;
out vec2 Texcoord;
uniform mat4 transf;
uniform mat4 proj;
uniform mat4 view;
void main()
{
Texcoord = texcoord;
vertexColor = col;
gl_Position = proj * view * transf * vec4(pos, 1.0);
}
typing glxinfo | grep 'version' in Linux terminal
Output:
server glx version string: 1.4
client glx version string: 1.4
GLX version: 1.4
Max core profile version: 4.
Max compat profile version: 3.0
Max GLES1 profile version: 1.1
Max GLES[23] profile version: 3.1
OpenGL core profile version string: 4.5 (Core Profile) Mesa 17.2.4
OpenGL core profile shading language version string: 4.50
OpenGL version string: 3.0 Mesa 17.2.4
OpenGL shading language version string: 1.30
OpenGL ES profile version string: OpenGL ES 3.1 Mesa 17.2.4
OpenGL ES profile shading language version string: OpenGL ES GLSL ES
3.10
Ubuntu version
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 16.04.3 LTS
Release: 16.04
Codename: xenial

Answer 1

Your code shouldn't really work on a conforming GL implementation. Adding glGetError() as #HolyBlackCat sugggested will result in a couple of errors, for example, you are using deprecated GL calls like glEnableClientState(), glLoadIdentity(), and so on - which all are not available in a core profile.
Actually I would not recommend adding glGetError() calls. Since you use GL 4.5, you can directly use a debug context. You will get human-readbale text messages for every error that occurs (and some more or less helpful hints beyond that).
One of the main issues I'm seeing in your code is this one:
glGenVertexArrays(0, &vao);
You are actually rendering without VAOs - which are mandatory in core profiles. Asking the GL to create zero VAOs won't get you anything, and then just binding some uninitialized variable as VAO isn't a good idea either.