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));
}
