void moTextureFilter::Apply(MOfloat p_cycle, MOfloat p_fade, moTextFilterParam *p_params) { MOint w = m_dest_tex[0]->GetWidth(); MOint h = m_dest_tex[0]->GetHeight(); SetGLConf(w, h); moShaderGLSL* pglsl = (moShaderGLSL*)m_shader; if (m_use_screen_tex) m_renderman->SaveScreen(); BindDestFBO(); m_shader->StartShader(); SetupShader(w, h, NULL, p_fade, p_params); BindSrcTex(p_cycle); m_shader->DrawGrid(w, h, m_src_tex.Count()); UnbindSrcTex(); m_shader->StopShader(); UnbindDestFBO(); RestoreGLConf(); }
//Initialisierungsfunktion void Initialize(int argc, char* argv[]) { GLenum GlewInitResult;//neue Variable vom Typ GLenum (um GLEW initialisation zu prüfen) //initialisiert das anzeige-Window InitWindow(argc, argv); glewExperimental = GL_TRUE;//GLEW erhät Informationen zu den Erweiterungen des Grafiktreibers GlewInitResult = glewInit();//initialisieren von GLEW //Überprüfen, ob GLEW Initialisierung erfolgreich, wenn nicht wird ein Error geworfen und Programm beendet if (GLEW_OK != GlewInitResult) { fprintf( stderr, "ERROR: %s\n", glewGetErrorString(GlewInitResult) ); glutExit(); } //Ausgabe der OpenGL Version fprintf( stdout, "INFO: OpenGL Version: %s\n", glGetString(GL_VERSION) ); glGetError();//gibt Fehlerinformationen aus glClearColor(0.20f, 0.2f, 0.2f, 0.0f); //setzt die Farbe, mit der die Buffer gecleart werden (Parameter bezüglich GLUT_RGBA) glEnable(GL_DEPTH_TEST);//aktiviert: Tiefenvergleiche und update des Tiefenbuffers (Wenn nicht aktiviert: kein tiefenvergleich, selbst mit aktiviertem Tiefenbuffer) glDepthFunc(GL_LESS);//Spezifiziert die Variable, die für den Tiefenbuffer genutzt wird (in diesem Fall: wenn Übergebene Tiefenvariable kleiner(Less) als die gespeicherte ist) ModelViewMatrixStack.loadIdentity();//setzt die aktuelle Matrix als Identitätsmatrix ProjectionMatrix.setIdentity();//setzt die Projektionsmatrix als Identitätsmatrix SetupShader();//Lädt und linked die shader LoadModel();//Lädt modelle loadTextures();//texturen laden initParticleSystem();//initialize particle system std::cout<<"\nChange Shader:\n"<< "1 - simple Shader\n"<< "2 - phong Shader\n"<< "\n"<< "Particle System:\n"<< "y - decrease maximum Lifetime of the particles\n"<< "x - increase maximum Lifetime of the particles\n"<< "\n"<< "c - decrease color alpha\n"<< "v - increase color alpha\n"<< "\n"<< "b - decrease particle count\n"<< "n - increase particle count\n"<< "\n"<< "o - increase comet speed\n"<< "l - decrease comet speed\n"; }
void Renderer::RenderFace(bsp_face *face) { const bsp_face ¤t_face = *face; Shader *shader = shaderLoader::GetShader(current_face.texture); if (shader->q3_shader_.stages_.size() == 0) // skip no shader / no draw. should be sorted out before. { return; } // does everything in here need to be done every time? move into the // conditional below? SetupShader(shader, current_face.lm_index); if (current_shader_ != shader) { glUseProgram(shader->shader_); current_shader_ = shader; } if (shader->time_idx_ != -1) { glUniform1f(shader->time_idx_, time_); } glUniformMatrix4fv(shader->projection_idx_, 1, false, glm::value_ptr(projectionmatrix_)); glUniformMatrix4fv(shader->model_idx_, 1, false, glm::value_ptr(modelmatrix_)); if (current_face.type == POLYGON || current_face.type == MESH) { // RenderPolygon(face); } else if (current_face.type == PATCH) { RenderPatch(face); } else if (current_face.type == BILLBOARD) { // RenderBillboard(); } }
void Canvas::DrawRenderTexture() { if( !m_render_texture ) { return; } if( !non_legacy_supported ) { // Matrix mode is currently GL_TEXTURE as set by Renderer. // We get ready for a surprise from SFML... CheckGLError( glPushMatrix() ); sf::Texture::bind( &( m_render_texture->getTexture() ) ); if( !m_display_list ) { m_display_list = glGenLists( 1 ); if( !m_display_list ) { #if defined( SFGUI_DEBUG ) std::cerr << "SFGUI warning: Canvas failed to create OpenGL display list.\n"; #endif } CheckGLError( glNewList( m_display_list, GL_COMPILE ) ); // Pop the texture matrix that SFML secretly loaded behind our backs... CheckGLError( glMatrixMode( GL_TEXTURE ) ); CheckGLError( glPopMatrix() ); CheckGLError( glColor3ub( 255, 255, 255 ) ); // Oh the horror... not. CheckGLError( glMatrixMode( GL_MODELVIEW ) ); CheckGLError( glPushMatrix() ); CheckGLError( glLoadIdentity() ); CheckGLError( glMatrixMode( GL_PROJECTION ) ); CheckGLError( glPushMatrix() ); CheckGLError( glLoadIdentity() ); CheckGLError( glBegin( GL_QUADS ) ); CheckGLError( glTexCoord2s( 0, 0 ) ); CheckGLError( glVertex2s( -1, -1 ) ); CheckGLError( glTexCoord2s( 1, 0 ) ); CheckGLError( glVertex2s( 1, -1 ) ); CheckGLError( glTexCoord2s( 1, 1 ) ); CheckGLError( glVertex2s( 1, 1 ) ); CheckGLError( glTexCoord2s( 0, 1 ) ); CheckGLError( glVertex2s( -1, 1 ) ); CheckGLError( glEnd() ); CheckGLError( glPopMatrix() ); CheckGLError( glMatrixMode( GL_MODELVIEW ) ); CheckGLError( glPopMatrix() ); CheckGLError( glMatrixMode( GL_TEXTURE ) ); CheckGLError( glEndList() ); } CheckGLError( glCallList( m_display_list ) ); } else { // Non-Legacy if( !m_shader ) { SetupShader(); } if( !non_legacy_supported ) { // Fall back to legacy starting in this frame. DrawRenderTexture(); return; } if( !m_vbo ) { SetupVBO(); } auto is_vertex_array = CheckGLError( GLEXT_glIsVertexArray( m_vao ) ); if( !is_vertex_array ) { SetupVAO(); } struct Texture : sf::GlResource { sf::Vector2u unused1; sf::Vector2u unused2; unsigned int unused3; bool unused4; bool unused5; mutable bool pixels_flipped; sf::Uint64 unused6; }; // Just so that SFML doesn't mess with the texture matrix. const_cast<Texture*>( reinterpret_cast<const Texture*>( &( m_render_texture->getTexture() ) ) )->pixels_flipped = false; sf::Shader::bind( m_shader.get() ); CheckGLError( GLEXT_glBindVertexArray( m_vao ) ); CheckGLError( glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 ) ); CheckGLError( GLEXT_glBindVertexArray( 0 ) ); sf::Shader::bind( nullptr ); } }
void Renderer::RenderModel() { glBindBuffer(GL_ARRAY_BUFFER, lower->vboId_); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, lower->iboId_); Shader *shader = lower->shader_; SetupShader(shader, -1); glUseProgram(shader->shader_); current_shader_ = shader; modelmatrix_ = glm::translate( modelmatrix_, glm::vec3(world.enemy_->position_)); // glm::vec3(-589.0f, -275.0f, 25.0f) float temp_pitch = world.enemy_->pitch_; world.enemy_->pitch_ = 0.0f; GetCameraMatrixFromEntity(*world.enemy_); world.enemy_->pitch_ = temp_pitch; glm::mat4 test = glm::mat4( world.enemy_->look_.x, world.enemy_->look_.y, world.enemy_->look_.z, 0.0f, world.enemy_->right_.x, world.enemy_->right_.y, world.enemy_->right_.z, 0.0f, world.enemy_->up_.x, world.enemy_->up_.y, world.enemy_->up_.z, 0.0f, 1, 1, 1, 1.0f); glm::mat4 modelmatrix_legs = modelmatrix_ * test; int lower_frame = world.enemy_->lower_frame; glUniformMatrix4fv(shader->projection_idx_, 1, false, glm::value_ptr(projectionmatrix_)); glUniformMatrix4fv(shader->model_idx_, 1, false, glm::value_ptr(modelmatrix_legs)); glVertexAttribPointer( shader->position_idx_, 3, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(lower_frame * lower->surfaces_[0].num_verts * sizeof(my_vertex))); glVertexAttribPointer( shader->tex_coord_idx_, 2, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(lower_frame * lower->surfaces_[0].num_verts * sizeof(my_vertex) + sizeof(glm::vec3) * 2)); glDrawElements(GL_TRIANGLES, lower->surfaces_[0].num_triangles * 3, GL_UNSIGNED_INT, reinterpret_cast<void *>(0)); GetCameraMatrixFromEntity(*world.enemy_); test = glm::mat4(world.enemy_->look_.x, world.enemy_->look_.y, world.enemy_->look_.z, 0.0f, world.enemy_->right_.x, world.enemy_->right_.y, world.enemy_->right_.z, 0.0f, world.enemy_->up_.x, world.enemy_->up_.y, world.enemy_->up_.z, 0.0f, 1, 1, 1, 1.0f); modelmatrix_ = modelmatrix_ * test; int ofs_tag = lower_frame * (lower->header_.num_tags); glm::mat4 rotationMatrix1( lower->tags_[0 + ofs_tag].axis[0].x, lower->tags_[0 + ofs_tag].axis[0].y, lower->tags_[0 + ofs_tag].axis[0].z, 0, lower->tags_[0 + ofs_tag].axis[1].x, lower->tags_[0 + ofs_tag].axis[1].y, lower->tags_[0 + ofs_tag].axis[1].z, 0, lower->tags_[0 + ofs_tag].axis[2].x, lower->tags_[0 + ofs_tag].axis[2].y, lower->tags_[0 + ofs_tag].axis[2].z, 0, lower->tags_[0 + ofs_tag].origin.x, lower->tags_[0 + ofs_tag].origin.y, lower->tags_[0 + ofs_tag].origin.z, 1); modelmatrix_ = modelmatrix_ * rotationMatrix1; glBindBuffer(GL_ARRAY_BUFFER, upper->vboId_); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, upper->iboId_); int upper_frame = world.enemy_->upper_frame; glUniformMatrix4fv(shader->projection_idx_, 1, false, glm::value_ptr(projectionmatrix_)); glUniformMatrix4fv(shader->model_idx_, 1, false, glm::value_ptr(modelmatrix_)); glVertexAttribPointer( shader->position_idx_, 3, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(upper_frame * upper->surfaces_[0].num_verts * sizeof(my_vertex))); glVertexAttribPointer( shader->tex_coord_idx_, 2, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(upper_frame * upper->surfaces_[0].num_verts * sizeof(my_vertex) + sizeof(glm::vec3) * 2)); glDrawElements(GL_TRIANGLES, upper->surfaces_[0].num_triangles * 3, GL_UNSIGNED_INT, reinterpret_cast<void *>(0)); ofs_tag = upper_frame * (upper->header_.num_tags); glm::mat4 rotationMatrix0( upper->tags_[0 + ofs_tag].axis[0].x, upper->tags_[0 + ofs_tag].axis[0].y, upper->tags_[0 + ofs_tag].axis[0].z, 0, upper->tags_[0 + ofs_tag].axis[1].x, upper->tags_[0 + ofs_tag].axis[1].y, upper->tags_[0 + ofs_tag].axis[1].z, 0, upper->tags_[0 + ofs_tag].axis[2].x, upper->tags_[0 + ofs_tag].axis[2].y, upper->tags_[0 + ofs_tag].axis[2].z, 0, upper->tags_[0 + ofs_tag].origin.x, upper->tags_[0 + ofs_tag].origin.y, upper->tags_[0 + ofs_tag].origin.z, 1); modelmatrix_ = modelmatrix_ * rotationMatrix0; glBindBuffer(GL_ARRAY_BUFFER, head->vboId_); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, head->iboId_); int head_frame = 0; glUniformMatrix4fv(shader->projection_idx_, 1, false, glm::value_ptr(projectionmatrix_)); glUniformMatrix4fv(shader->model_idx_, 1, false, glm::value_ptr(modelmatrix_)); glVertexAttribPointer( shader->position_idx_, 3, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(head_frame * head->surfaces_[0].num_verts * sizeof(my_vertex))); glVertexAttribPointer( shader->tex_coord_idx_, 2, GL_FLOAT, GL_FALSE, sizeof(my_vertex), reinterpret_cast<void *>(head_frame * head->surfaces_[0].num_verts * sizeof(my_vertex) + sizeof(glm::vec3) * 2)); glDrawElements(GL_TRIANGLES, head->surfaces_[0].num_triangles * 3, GL_UNSIGNED_INT, reinterpret_cast<void *>(0)); }