Opengl sometimes works funnily - c++

Question

I want to draw 2 circles, and here are the necessary bits from three files of my project.
circle.h
#include "main.h"
#ifndef CIRCLE_H
#define CIRCLE_H
class Circle{
public:
Circle(){};
Circle(float x, float y, float radius, float fraction, color_t color);
void set_position(float x, float y);
void draw(glm::mat4 VP);
bounding_box_t bounding_box();
glm::vec3 position;
float rotation;
float radius;
float fraction;
private:
VAO *object;
};
#endif //CIRCLE_H
circle.cpp
#include "circle.h"
#include "main.h"
#include <iostream>
#define PI 3.14159265358979323846
typedef struct {
GLfloat x;
GLfloat y;
GLfloat z;
}point;
point rotate_by(double angle, point inp_point){
point new_point;
new_point.x = inp_point.x*cos(angle) - inp_point.y*sin(angle);
new_point.y = inp_point.x*sin(angle) + inp_point.y*cos(angle);
return new_point;
};
void fill_array(int sides, float radius, int fraction, GLfloat array[]){
double angle = 2 * PI / sides;
point vertex;
vertex.x = 0.0f;
vertex.y = 0.0f;
vertex.z = 0.0f;
point oldpoint;
oldpoint.x = 0.0f;
oldpoint.y = radius;
oldpoint.z = 0.0f;
int iterations = (int)(fraction*sides);
std::cout<< iterations <<std::endl;
//For each triangle
for(int i = 0; i < iterations; i++){
// setting the vertex
array[9*i + 0] = vertex.x;
array[9*i + 1] = vertex.y;
array[9*i + 2] = vertex.z;
// setting the oldpoint
array[9*i + 3] = oldpoint.x;
array[9*i + 4] = oldpoint.y;
array[9*i + 5] = oldpoint.z;
// making the new point
point newpoint = rotate_by(angle, oldpoint);
// setting the new point
array[9*i + 6] = newpoint.x;
array[9*i + 7] = newpoint.y;
array[9*i + 8] = newpoint.z;
// New point is now old
oldpoint = newpoint;
}
};
Circle::Circle(float x, float y, float radius, float fraction, color_t color) {
this->position = glm::vec3(x, y, 0);
this->rotation = 0;
int sides = 50;
this->radius = radius;
this->fraction = fraction;
static GLfloat vertex_buffer_data[1000];
fill_array(sides, radius, fraction, vertex_buffer_data);
int num_vertices = (int)(fraction*sides)*3;
std::cout << num_vertices <<std::endl;
this->object = create3DObject(GL_TRIANGLES, num_vertices, vertex_buffer_data, color, GL_FILL);
}
void Circle::draw(glm::mat4 VP) {
Matrices.model = glm::mat4(1.0f);
glm::mat4 translate = glm::translate (this->position); // glTranslatef
glm::mat4 rotate = glm::rotate((float) (this->rotation * M_PI / 180.0f), glm::vec3(0, 0, 1));
rotate = rotate * glm::translate(glm::vec3(0, -0.6, 0));
Matrices.model *= (translate * rotate);
glm::mat4 MVP = VP * Matrices.model;
glUniformMatrix4fv(Matrices.MatrixID, 1, GL_FALSE, &MVP[0][0]);
draw3DObject(this->object);
}
main.cpp
//-------------------Necessary tools----------------------------------------------
#include <vector>
#include <random>
#include "timer.h"
#include "main.h"
using namespace std;
//------------------Template Imports---------------------------------------------
#include "circle.h"
//---------------Important declarations-------------------------------------------
GLMatrices Matrices;
GLuint programID;
GLFWwindow *window;
float screen_zoom = 1, screen_center_x = 0, screen_center_y = 0;
Timer t60(1.0 / 60);
//--------------Object declarations-----------------------------------------------
Circle c1;
Circle c2;
// -------------Functions----------------------------------------------------------
void draw() {
//---------Don't touch---------------------------------------------------------
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram (programID);
Matrices.view = glm::lookAt(glm::vec3(0, 0, 3), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0)); // Fixed camera for 2D (ortho) in XY plane
glm::mat4 VP = Matrices.projection * Matrices.view;
glm::mat4 MVP;
//---------Scene render--------------------------------------------------------
c1.draw(VP);
c2.draw(VP);
}
void initGL(GLFWwindow *window, int width, int height) {
//-----------Create objects----------------------------------------------
c1 = Circle(1,1,1.0f,1.0f,COLOR_BLACK);
c2 = Circle(2,2,1.0f,1.0f, COLOR_RED);
//-----------Don't touch-------------------------------------------------
programID = LoadShaders("Sample_GL.vert", "Sample_GL.frag");
Matrices.MatrixID = glGetUniformLocation(programID, "MVP");
reshapeWindow (window, width, height);
glClearColor (COLOR_BACKGROUND.r / 256.0, COLOR_BACKGROUND.g / 256.0, COLOR_BACKGROUND.b / 256.0, 0.0f); // R, G, B, A
glClearDepth (1.0f);
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LEQUAL);
cout << "VENDOR: " << glGetString(GL_VENDOR) << endl;
cout << "RENDERER: " << glGetString(GL_RENDERER) << endl;
cout << "VERSION: " << glGetString(GL_VERSION) << endl;
cout << "GLSL: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
}
int main(int argc, char **argv) {
srand(time(0));
int width = 600;
int height = 600;
window = initGLFW(width, height);
initGL (window, width, height);
/* Draw in loop */
while (!glfwWindowShouldClose(window)) {
// Process timers
if (t60.processTick()) {
// 60 fps
// OpenGL Draw commands
draw();
// Swap Frame Buffer in double buffering
glfwSwapBuffers(window);
tick_elements();
//tick_input(window);
}
// Poll for Keyboard and mouse events
glfwPollEvents();
}
quit(window);
}
void reset_screen() {
float top = screen_center_y + 4 / screen_zoom;
float bottom = screen_center_y - 4 / screen_zoom;
float left = screen_center_x - 4 / screen_zoom;
float right = screen_center_x + 4 / screen_zoom;
Matrices.projection = glm::ortho(left, right, bottom, top, 0.1f, 500.0f);
}
For some reason, sometimes, I get the right output, but sometimes, I get funny outputs.
This is the correct image that I want:
But several times nothing appears at all:
Sometimes really funny outputs appear, like this:
... And this:
Notice that I am not even running make again and again, these variations happen each time I am opening the executable itself.
How can I get the correct output every time?

Answer 1

Do you call reset_screen() function somewhere? Because in this function you are creating your projection matrix. It looks like this matrix is uninitialized (initialized with some trash).