void LinesRenderer::render(Vbo& vbo, RenderContext& context) {
Renderer::SetVboState activateVbo(vbo, Renderer::Vbo::VboActive);
if (!m_valid) {
delete m_vertexArray;
m_vertexArray = NULL;
if (!m_vertices.empty()) {
Renderer::SetVboState mapVbo(vbo, Renderer::Vbo::VboMapped);
m_vertexArray = new VertexArray(vbo, GL_LINES, static_cast<unsigned int>(m_vertices.size()), Attribute::position3f(), 0);
m_vertexArray->addAttributes(m_vertices);
m_vertices.clear();
m_valid = true;
}
}
if (m_vertexArray != NULL) {
Renderer::glSetEdgeOffset(0.3f);
Renderer::ActivateShader handleShader(context.shaderManager(), Renderer::Shaders::HandleShader);
glDisable(GL_DEPTH_TEST);
handleShader.setUniformVariable("Color", m_occludedColor);
m_vertexArray->render();
glEnable(GL_DEPTH_TEST);
handleShader.setUniformVariable("Color", m_color);
m_vertexArray->render();
Renderer::glResetEdgeOffset();
}
}
int main(int argc, char *argv[]){
if(!glfwInit()){
throw std::runtime_error("glfwInit failed");
}
glfwOpenWindowHint(0, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
if(!glfwOpenWindow(800, 600, 8, 8, 8, 8, 0, 0, GLFW_WINDOW)){
throw std::runtime_error("glfwOpenWindow failed. does this hardware work with 3.1");
}
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK){
throw std::runtime_error("glewInit failed");
}
if(!GLEW_VERSION_3_1){
throw std::runtime_error("OpenGL 3.1 API is not available");
}
printf("loading vertex shader\n");
handleShader("vertex.shader", GL_VERTEX_SHADER);
printf("loading fragment shader\n");
handleShader("fragment.shader", GL_FRAGMENT_SHADER);
printf("Shaders loaded\n");
printf("Building shader program\n");
shaderprogram = glCreateProgram();
if(shaderprogram == 0){
throw std::runtime_error("glCreateProgram failed");
}
glAttachShader(shaderprogram, vertshader);
glAttachShader(shaderprogram, fragshader);
glLinkProgram(shaderprogram);
GLint status;
glGetProgramiv(shaderprogram, GL_LINK_STATUS, &status);
if(status == GL_FALSE){
std::string msg("Program linking failure: ");
GLint infologlen;
glGetProgramiv(shaderprogram, GL_INFO_LOG_LENGTH, &infologlen);
char* strinfolog = new char[infologlen + 1];
glGetProgramInfoLog(shaderprogram, infologlen, NULL, strinfolog);
msg += strinfolog;
delete[] strinfolog;
glDeleteProgram(shaderprogram);
throw std::runtime_error(msg);
}
GLint vertprog = glGetAttribLocation(shaderprogram,"vert");
GLint verttexprog = glGetAttribLocation(shaderprogram,"vertTexCoord");
//bind VAO
glGenVertexArrays(1, &cubeVAO);
glBindVertexArray(cubeVAO);
//bind VBO
glGenBuffers(1, &cubeVBO);
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
glEnableVertexAttribArray(vertprog);
glVertexAttribPointer(vertprog, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), NULL);
glEnableVertexAttribArray(verttexprog);
glVertexAttribPointer(verttexprog, 2, GL_FLOAT, GL_TRUE, 5*sizeof(GLfloat), (const GLvoid*)(3*sizeof(GLfloat)));
uniform = glGetUniformLocation(shaderprogram, "tex");
glBindVertexArray(0);
glGenTextures( 1, &texture);
glBindTexture( GL_TEXTURE_2D, texture);
imgdata image_data = loadJpeg("new.jpg");
//imgdata image_data = loadRaw("texture.bmp", 256, 256);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, image_data.data);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image_data.width, image_data.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data.data);
//free( imgdata );
while(glfwGetWindowParam(GLFW_OPENED)){
display();
}
glfwTerminate();
return 0;
}
void LoadGeometry(){
printf("loading 3d-vertex shader\n");
handleShader("3d-vertex.shader", GL_VERTEX_SHADER);
printf("loading 3d-fragment shader\n");
handleShader("3d-fragment.shader", GL_FRAGMENT_SHADER);
printf("3d Shaders loaded\n");
printf("loading 2d-Vertex shader\n");
handleShader2d("2d-vertex.shader", GL_VERTEX_SHADER);
printf("loading 2d-fragment shader\n");
handleShader2d("2d-fragment.shader", GL_FRAGMENT_SHADER);
printf("2d Shaders loaded\n");
printf("loading text vertex shader\n");
handleShaderText("text-vertex.shader", GL_VERTEX_SHADER);
printf("loading text fragment shader\n");
handleShaderText("text-fragment.shader", GL_FRAGMENT_SHADER);
printf("text shaders loaded\n");
printf("Building shader program\n");
shader3dprogram = glCreateProgram();
if(shader3dprogram == 0){
throw std::runtime_error("glCreateProgram failed");
}
shader2dprogram = glCreateProgram();
if( shader2dprogram == 0 ){
throw std::runtime_error("glCreateProgram failed");
}
textprogram = glCreateProgram();
if( textprogram == 0){
throw std::runtime_error("glCreateProgram failed");
}
glAttachShader(shader3dprogram, vertshader3d);
glAttachShader(shader3dprogram, fragshader3d);
glAttachShader(shader2dprogram, vertshader2d);
glAttachShader(shader2dprogram, fragshader2d);
glAttachShader(textprogram, textvertshader);
glAttachShader(textprogram, textfragshader);
glLinkProgram(shader3dprogram);
glLinkProgram(shader2dprogram);
glLinkProgram(textprogram);
GLint status;
glGetProgramiv(shader3dprogram, GL_LINK_STATUS, &status);
if(status == GL_FALSE){
std::string msg("Program linking failure: ");
GLint infologlen;
glGetProgramiv(shader3dprogram, GL_INFO_LOG_LENGTH, &infologlen);
char* strinfolog = new char[infologlen + 1];
glGetProgramInfoLog(shader3dprogram, infologlen, NULL, strinfolog);
msg += strinfolog;
delete[] strinfolog;
glDeleteProgram(shader3dprogram);
throw std::runtime_error(msg);
}
glGetProgramiv(shader2dprogram, GL_LINK_STATUS, &status);
if(status == GL_FALSE){
std::string msg("Program linking failure: ");
GLint infologlen;
glGetProgramiv(shader2dprogram, GL_INFO_LOG_LENGTH, &infologlen);
char* strinfolog = new char[infologlen + 1];
glGetProgramInfoLog(shader2dprogram, infologlen, NULL, strinfolog);
msg += strinfolog;
delete[] strinfolog;
glDeleteProgram(shader2dprogram);
throw std::runtime_error(msg);
}
glGetProgramiv(textprogram, GL_LINK_STATUS, &status);
if(status == GL_FALSE){
std::string msg("Program linking failure: ");
GLint infologlen;
glGetProgramiv(textprogram, GL_INFO_LOG_LENGTH, &infologlen);
char* strinfolog = new char[infologlen + 1];
glGetProgramInfoLog(textprogram, infologlen, NULL, strinfolog);
msg += strinfolog;
delete[] strinfolog;
glDeleteProgram(textprogram);
throw std::runtime_error(msg);
}
GLint vertprog = glGetAttribLocation(shader3dprogram,"vert");
GLint verttexprog = glGetAttribLocation(shader3dprogram,"vertTexCoord");
GLint vertnormprog = glGetAttribLocation(shader3dprogram,"vertNormal");
printf( "vertprog is %d\n", vertprog);
GLint overlayprog = glGetAttribLocation(shader2dprogram, "vert");
//textprog = -1;
textprog = glGetAttribLocation(textprogram, "coord");
printf( "textprog is %d\n", textprog);
//bind VAO
glGenVertexArrays(1, &cubeVAO);
glBindVertexArray(cubeVAO);
//bind VBO
glGenBuffers(1, &cubeVBO);
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
glEnableVertexAttribArray(vertprog);
glVertexAttribPointer(vertprog, 3, GL_FLOAT, GL_FALSE, 8*sizeof(GLfloat), NULL);
glEnableVertexAttribArray(verttexprog);
glVertexAttribPointer(verttexprog, 2, GL_FLOAT, GL_TRUE, 8*sizeof(GLfloat), (const GLvoid*)(3*sizeof(GLfloat)));
glEnableVertexAttribArray(vertnormprog);
glVertexAttribPointer(vertnormprog, 3, GL_FLOAT, GL_TRUE, 8*sizeof(GLfloat), (const GLvoid*)(5*sizeof(GLfloat)));
//glBindVertexArray(0);
//setup overlay
glGenVertexArrays(1, &overlayVAO);
glBindVertexArray(overlayVAO);
glGenBuffers(1, &overlayVBO);
glBindBuffer(GL_ARRAY_BUFFER, overlayVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(overlay), overlay, GL_STATIC_DRAW);
glEnableVertexAttribArray(overlayprog);
glVertexAttribPointer(overlayprog, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat),NULL);
//setup text
glGenVertexArrays(1, &textVAO);
glBindVertexArray(textVAO);
glGenBuffers(1, &textVBO);
glBindBuffer(GL_ARRAY_BUFFER, textVBO);
glEnableVertexAttribArray(textprog);
glVertexAttribPointer(textprog, 4, GL_FLOAT, GL_FALSE,4*sizeof(GLfloat),NULL);
glBindVertexArray(0);
printf("Geometry loaded\n");
}