PDA

View Full Version : OpenGL primitive Restart



korgan00
07-13-2013, 05:55 AM
Im learning about opengl 4.3 and I am doing an reference guide book's example using SDL 2.0.
The only thing that i can see is a black window, i dont know what i should do. Anyone can help me?

Here is my code:

This is Demo_OGL_2.h:


#ifndef DEMO_OGL_II_H_
#define DEMO_OGL_II_H_
#include <iostream>
#include <GL/gl3w.h>
#include <GL/gl3.h>
#include "SDL2/SDL.h"
#include "LoadShaders.h"

class Demo_OGL_2 {
private:
bool running;
SDL_Window* window;
SDL_GLContext ctxt;

static const uint32_t WIN_HEIGHT = 768; //px
static const uint32_t WIN_WIDTH = 1024; //px
static const char* WIN_TITLE; //px

/************************************************** */
/************************************************** */
/************************************************** */


float aspect;
static const GLfloat cube_positions[];
static const GLfloat cube_colors[];
static const GLushort cube_indices[];
GLuint ebo[1];
GLuint vao[1];
GLuint vbo[1];

GLuint render_prog;
GLuint render_model_matrix_loc;
GLuint render_projection_matrix_loc;

/*
enum VAO_IDs { Triangles, NumVAOs };
enum Buffer_IDs { ArrayBuffer, NumBuffers };
enum Attrib_IDs { vPosition = 0, vColor = 1 };

GLuint VAOs[NumVAOs];
GLuint Buffers[NumBuffers];

static const GLuint NumVertices = 6;*/
public:

Demo_OGL_2();
int Execute(){ return OnExecute(); }
bool Init(){ return OnInit(); }
void Loop(){ return OnLoop(); }
void Render(){ return OnRender(); }
void Cleanup(){ return OnCleanup(); }
void Event(SDL_Event* Event){ OnEvent(Event); }



int OnExecute();

bool OnInit();
void OnEvent(SDL_Event* Event);
void OnLoop();
void OnRender();
void OnCleanup();



void setupOpenGl();

/************************************************** */
/************************************************** */
/************************************************** */

void exInit();
};


#endif /* DEMO_OGL_I_H_ */


And this is my Demo_OGL_2.cpp:



#include <iostream>
#include "Demo_OGL_2.h"
#include "../../LibsNUtils/vmath.h"
#include <GL/gl3w.h>
#include <GL/gl3.h>
#include "LoadShaders.h"
//#define BUFFER_OFFSET(offset) ((void *) (offset))

const char* Demo_OGL_2::WIN_TITLE = "Titulo de la Ventana";
const GLfloat Demo_OGL_2::cube_positions[] = {
-1.0f, -1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
const GLfloat Demo_OGL_2::cube_colors[] = {
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f
};
const GLushort Demo_OGL_2::cube_indices[] = {
0, 1, 2, 3, 6, 7, 4, 5, // First strip
0xFFFF, // <<-- This is the restart index
2, 6, 0, 4, 1, 5, 3, 7 // Second strip
};

Demo_OGL_2::Demo_OGL_2() : running(false), window(NULL), ctxt(NULL),
aspect(0), ebo(), vao(), vbo(),
render_prog(0), render_model_matrix_loc(0), render_projection_matrix_loc(0){}

void Demo_OGL_2::OnEvent(SDL_Event* event) {
switch (event->type) {
case SDL_KEYUP:
switch(event->key.keysym.sym){
case SDLK_v:
std::cout << glGetString(GL_VERSION) << std::endl;
break;
case SDLK_ESCAPE:
running = false;
break;
default:
break;
}
break;
case SDL_QUIT:
running = false;
break;
default:
break;
}
}
void Demo_OGL_2::OnLoop() {}

void Demo_OGL_2::OnRender() {

float t = float(GetTickCount() & 0x1FFF) / float(0x1FFF);
//static float q = 0.0f;
static const vmath::vec3 X(1.0f, 0.0f, 0.0f);
static const vmath::vec3 Y(0.0f, 1.0f, 0.0f);
static const vmath::vec3 Z(0.0f, 0.0f, 1.0f);

glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glUseProgram(render_prog);

vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, -5.0f) *
vmath::rotate(t * 360.0f, Y) *
vmath::rotate(t * 720.0f, Z));
vmath::mat4 projection_matrix(vmath::frustum(-1.0f, 1.0f, -aspect, aspect, 1.0f, 500.0f));

glUniformMatrix4fv(render_model_matrix_loc, 4, GL_FALSE, model_matrix);
glUniformMatrix4fv(render_projection_matrix_loc, 1, GL_FALSE, projection_matrix);

glBindVertexArray( vao[0] );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo[0]);


#define USE_PRIMITIVE_RESTART 0
#if USE_PRIMITIVE_RESTART
// When primitive restart is on, we can call one draw command
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(0xFFFF);
glDrawElements(GL_TRIANGLE_STRIP, 17, GL_UNSIGNED_SHORT, NULL);
#else
// Without primitive restart, we need to call two draw commands
glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT, NULL);
glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT,
(const GLvoid *)(9 * sizeof(GLushort)));
#endif


SDL_GL_SwapWindow(window);
}

void Demo_OGL_2::OnCleanup() {
glUseProgram(0);
glDeleteProgram(render_prog);
glDeleteVertexArrays(1, vao);
glDeleteBuffers(1, vbo);
SDL_GL_DeleteContext(ctxt);
SDL_DestroyWindow(window);
SDL_Quit();
}

bool Demo_OGL_2::OnInit() {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
return false;

window = SDL_CreateWindow(WIN_TITLE,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WIN_WIDTH, WIN_HEIGHT,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
if(!window)
return false;

setupOpenGl();
exInit();

running = true;

return true;
}
void Demo_OGL_2::setupOpenGl(){
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
ctxt = SDL_GL_CreateContext(window);

//vsync ON
SDL_GL_SetSwapInterval(1);

if (gl3wInit()) {
std::cout << "Error al Inicializar GL3W" << std::endl;
}


}
void Demo_OGL_2::exInit(){

ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "Resources/Demo_OGL_II/primitive_restart.vs.glsl" },
{ GL_FRAGMENT_SHADER, "Resources/Demo_OGL_II/primitive_restart.fs.glsl" },
{ GL_NONE, NULL }
};

render_prog = LoadShaders( shaders );
glUseProgram( render_prog );

render_model_matrix_loc = glGetUniformLocation(render_prog, "model_matrix");
render_projection_matrix_loc = glGetUniformLocation(render_prog, "projection_matrix");


glGenBuffers(1, ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_indices), cube_indices, GL_STATIC_DRAW);

glGenVertexArrays(1, vao);
glBindVertexArray(vao[0]);

glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_positions) + sizeof(cube_colors), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_positions), cube_positions );
glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_positions), sizeof(cube_colors), cube_colors);

glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)sizeof(cube_positions));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);



glViewport(0, 0, WIN_WIDTH, WIN_HEIGHT);
aspect = float(WIN_HEIGHT) / float(WIN_WIDTH);
}

int Demo_OGL_2::OnExecute() {
if (!Init())
return -1;

SDL_Event event;

while (running) {

while (SDL_PollEvent(&event))
Event(&event);

Loop();
Render();
}

Cleanup();

return 0;
}

Vertex Shader:


#version 330

uniform mat4 model_matrix;
uniform mat4 projection_matrix;

layout (location = 0) in vec4 position;
layout (location = 1) in vec4 color;

out vec4 vs_fs_color;

void main(void)
{
vs_fs_color = color;
gl_Position = projection_matrix * (model_matrix * position);
}


And the simplest fragment shader


#version 430

in vec4 vs_fs_color;

layout (location = 0) out vec4 color;

void main(void)
{
color = vs_fs_color;
}

tonyo_au
07-13-2013, 06:57 PM
vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, -5.0f) *
vmath::rotate(t * 360.0f, Y) *
vmath::rotate(t * 720.0f, Z));


These rotation do nothing but I would keep my roations in the range 0 <= r < 360.

You have placed your camera at 0,0,-5 looking down the -z axis
You have placed your object at 0,0,0

So you are not looking at your object

vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, 5.0f)

In general it is easier to use a lookat function to place cameras

korgan00
07-14-2013, 06:32 AM
"t" is between 0-1, rotate use a fraction of 360 and 720, i think that this rotations are alright.

model_matrix is a transformation matrix for cube, not for camera, then, camera is on 0,0,0 looking at -Z and cube on 0,0,-5. thats alright? i was testing with 0,0,5 , 0,5,0 , 0,-5,0 ... And still black window. I dont know what should i do. Any suggestion?

tonyo_au
07-14-2013, 06:48 PM
Try changing your projection matrix. Perhaps 1,-1, and aspect are too narrow. Or you could try the alternate way of setting the projection matrix with angle and aspect

korgan00
07-15-2013, 09:16 AM
Those are normalized values if im on the right way. Anyway, i tryed bigger values and still the same result.
Im sure, that im forgetting something. Someone can compile and test it?

thokra
07-16-2013, 04:26 AM
glUniformMatrix4fv(render_model_matrix_loc, 4, GL_FALSE, model_matrix);

Replace 4 with 1. model_matrix is a single matrix and not an array of 4 matrices. I suppose you're getting an INVALID_OPERATION here, thus no model is uploaded and thus no transformation is happening.

korgan00
07-16-2013, 04:45 AM
Oh thx, it is working now!!! i can continue with my learning :)
manythx again!

thokra
07-16-2013, 04:51 AM
You're welcome.


Oh thx, it is working now!!! i can continue with my learning :)

A sound advice: In case of emergency, always check for GL errors first! :)

korgan00
07-16-2013, 11:13 AM
Thx, i will!