void ShaderManager::LoadShaderFiles(std::vector<std::string> &program_names) { std::string directory; //Load and compile the shaders directory = project_mode_string + "vertex_shaders.txt"; compileShaders(GL_VERTEX_SHADER, directory); directory = project_mode_string + "fragment_shaders.txt"; compileShaders(GL_FRAGMENT_SHADER, directory); //Link the programs createPrograms(); //Get shader names to send back SPIterator it = shader_programs.begin(); for(; it!= shader_programs.end(); it++) { program_names.push_back((*it).first); } }
void TopazSample::initRendering() { if (!GLEW_ARB_bindless_texture) { LOGI("This sample requires ARB_bindless_texture"); exit(EXIT_FAILURE); } bindlessVboUbo = GLEW_NV_vertex_buffer_unified_memory && requireExtension("GL_NV_uniform_buffer_unified_memory", false); NvAssetLoaderAddSearchPath("Topaz/Topaz"); if(!requireMinAPIVersion(NvGfxAPIVersionGL4_4(), true)) { exit(EXIT_FAILURE); } compileShaders("draw", "shaders/vertex.glsl", "shaders/fragment.glsl"); /* If needed geometry shader: compileShaders("geometry", "shaders/vertex.glsl", "shaders/fragment.glsl", "shaders/geometry.glsl"); */ compileShaders("weightBlended", "shaders/vertex.glsl", "shaders/fragmentBlendOIT.glsl"); compileShaders("weightBlendedFinal", "shaders/vertexOIT.glsl", "shaders/fragmentFinalOIT.glsl"); // like as glClearBufferfv for nv_command_list compileShaders("clear", "shaders/vertexOIT.glsl", "shaders/clear.glsl"); loadModel("models/background.obj", shaderPrograms["draw"]->getProgram()); loadModel("models/way3.obj", shaderPrograms["draw"]->getProgram(), true); loadModel("models/way4.obj", shaderPrograms["draw"]->getProgram(), true); loadModel("models/way5.obj", shaderPrograms["draw"]->getProgram()); loadModel("models/formular.obj", shaderPrograms["draw"]->getProgram()); textures.skybox = NvImage::UploadTextureFromDDSFile("textures/sky_cube.dds"); cmdlist.state.programIncarnation++; CHECK_GL_ERROR(); }
void Application::update(float time, float timeSinceLastFrame) { if (comp_shaders == 1){ compileShaders(); comp_shaders = 0; } if (m_w_pressed) m_camera.Move(CameraDirection::FORWARD); if (m_s_pressed) m_camera.Move(CameraDirection::BACK); if (m_a_pressed) m_camera.Move(CameraDirection::LEFT); if (m_d_pressed) m_camera.Move(CameraDirection::RIGHT); if (m_q_pressed) m_camera.Move(CameraDirection::UP); if (m_e_pressed) m_camera.Move(CameraDirection::DOWN); // Updating the camera matrices m_camera.Update(); m_camera.GetMatricies(m_projmat, m_viewmat, m_worldmat); m_inv_viewmat = glm::inverse(m_viewmat); glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer); glm::mat4* transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT); transform_matrices[0] = m_projmat; transform_matrices[1] = m_viewmat; transform_matrices[2] = m_worldmat; glUnmapBuffer(GL_UNIFORM_BUFFER); // updating the lighting info glBindBufferBase(GL_UNIFORM_BUFFER, 1, m_lighting_buffer); glm::vec4* light_info = (glm::vec4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 2 * sizeof(glm::vec4), GL_MAP_WRITE_BIT); light_info[0] = glm::vec4(-1, -1, -1, 0); light_info[1] = glm::vec4(m_camera.getPosition(), 1.0f); glUnmapBuffer(GL_UNIFORM_BUFFER); // Buffer 2 is reserved for the sample points of the Ambient Occlusion Rendering // updating the general information for every object glBindBufferBase(GL_UNIFORM_BUFFER, 3, m_general_buffer); glm::vec4* general_info = (glm::vec4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 2 * sizeof(glm::vec4), GL_MAP_WRITE_BIT); glUnmapBuffer(GL_UNIFORM_BUFFER); }
void GLContext::realize(int width, int height) { width_ = width; height_ = height; glViewport(0, 0, width, height); glDepthRange(0.0f, 1.0f); initDefaultMap(defaultAmbientMap, 0x808080); initDefaultMap(defaultDiffuseMap, 0x808080); initDefaultMap(defaultSpecularMap, 0x808080); initDefaultMap(defaultEmissiveMap, 0x000000); initDefaultMap(defaultOpacityMap, 0xffffff); initDefaultMap(defaultCustomMap, 0xffffff); compileShaders(); }
void Shadertoy::loop() { GLuint points_vbo; glGenBuffers (1, &points_vbo); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW); GLuint vao; glGenVertexArrays (1, &vao); glBindVertexArray (vao); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); if (!loadFromFile()) { compileShaders(vertexSource, fragmentSource); } auto pos = glGetAttribLocation(program, "position"); glEnableVertexAttribArray (pos); auto time = glGetUniformLocation(program, "global_time"); auto resolution = glGetUniformLocation(program, "resolution"); glUseProgram(program); while (!glfwWindowShouldClose(win)) { glfwGetWindowSize(win, &g_width, &g_heigth); updateFpsCounter(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport(0, 0, g_width, g_heigth); auto current_time = glfwGetTime(); glUniform1f(time, current_time); glUniform2f(resolution, g_width, g_heigth); if(recompile) { loadFromFile(); glUseProgram(program); recompile = false; } glBindVertexArray (vao); glDrawArrays(GL_TRIANGLE_STRIP, 0, 6); glfwPollEvents(); glfwSwapBuffers(win); } }
static int initRenderOpenGLES2() { if(!compileShaders(vertexShader, fragmentShader, &vertexShaderObjectId, &fragmentShaderObjectId, &programObjectId)) { renderer.destroy(); return 0; } if(!setupAttribLocations(&programObjectId, &_positionSlot, &_colorSlot, &_projectionUniform, &_modelViewUniform)){ renderer.destroy(); return 0; } if(!setupVBOs(&vertexBuffer, &indexBuffer, sizeof(verticesES2), verticesES2, sizeof(indicesES2), indicesES2)) { renderer.destroy(); return 0; } return 1; }
void init(EntityManager<EntityManagerTypes...> *entityManagerRef, std::string resourcesPath) { this->entityManagerRef = entityManagerRef; spriteShaderProgramId = compileShaders("sprite shaders", SPRITE_VERTEX_SHADER, SPRITE_FRAGMENT_SHADER); if (spriteShaderProgramId == -1) { // we're boned :/ printf("OH NOES, SHADERS FAILED TO COMPILE...\n"); exit(1); } boundsSprite.init(spriteShaderProgramId, resourcesPath + "DebugBounds.png"); componentMask |= 1 << getTypeId<TransformComponent>(); componentMask |= 1 << getTypeId<AABBComponent>(); }
bool RadialBlur::createResources() { /* Delete old shader */ deleteResources(); /* Create new resources */ if (!compileShaders()) { io::Log::error("Compiling shaders for radial-blur failed"); deleteResources(); return false; } /* Validate effect */ Valid_ = true; return true; }
void Application::create() { compileShaders(); const float vertices[] = { 1.0f, -0.5f, -0.5f, 1.0f, -0.5f, 0.5f, 1.0f, 0.5f, 0.0f }; const float colors[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; glGenBuffers(1, &vertices_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glGenBuffers(1, &colors_buffer); glBindBuffer(GL_ARRAY_BUFFER, colors_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW); const float mirror_vertices[] = { 0.0f, -1.0f,-1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f }; const float mirror_colors[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.4f, 0.7f, 0.1f }; glGenBuffers(1, &mirror_vertices_buffer); glBindBuffer(GL_ARRAY_BUFFER, mirror_vertices_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(mirror_vertices), mirror_vertices, GL_STATIC_DRAW); glGenBuffers(1, &mirror_colors_buffer); glBindBuffer(GL_ARRAY_BUFFER, mirror_colors_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(mirror_colors), mirror_colors, GL_STATIC_DRAW); }
void keyboard(GLFWwindow* window, int key, int scancode, int action, int mode) { Camera* cam = (Camera*)glfwGetWindowUserPointer(window); if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) glfwSetWindowShouldClose(window, 1); /*if (key == GLFW_KEY_SPACE) cam->Position.y += .01f;*/ if (key == GLFW_KEY_LEFT_SHIFT || key == GLFW_KEY_RIGHT_SHIFT) cam->Position.y -= .01f; if (key == GLFW_KEY_P && action == GLFW_RELEASE) printf("%f, %f, %f", cam->Position.x, cam->Position.y, cam->Position.z); /*if (key == GLFW_KEY_X && action == GLFW_RELEASE) wireframe = !wireframe;*/ if (key == GLFW_KEY_SPACE && action == GLFW_RELEASE) { screenShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl"); std::cout << "Recompiled" << std::endl; } }
void initializeText(int width,int height){ screenWidth = width; screenHeight = height; // Initialize VBO glGenBuffers(1, &Text2DVertexBufferID); glGenBuffers(1, &Text2DUVBufferID); // Initialize Shader Text2DShaderID = compileShaders("TextPixelShader.glsl","TextVertexShader.glsl"); // Initialize uniforms' IDs Text2DUniformID = glGetUniformLocation(Text2DShaderID, "basic_texture"); Text2DresID = glGetUniformLocation(Text2DShaderID, "resolution"); }
GLuint loadShaders(const char *vertFileName, const char *fragFileName) // TO DO: Add geometry shader support { char *vs, *fs; GLuint p; vs = readFile((char *)vertFileName); fs = readFile((char *)fragFileName); if ((vs==NULL)||(fs==NULL)) // bug fixed 120126 { printf("Loading shaders failed.\n"); return 0; // Some better error reporting desired. } p = compileShaders(vs, fs); if (vs != NULL) free(vs); if (fs != NULL) free(fs); return p; }
GLuint loadShaders(const char *vertFileName, const char *fragFileName) // TO DO: Add geometry shader support { // const char *vs, *fs; GLuint p; vs = readFile((char *)vertFileName); fs = readFile((char *)fragFileName); if ((vs==NULL)||(fs==NULL)) { printf("Loading shaders failed.\n"); return 0; } p = compileShaders(vs, fs); if (vs != NULL) free(vs); if (fs != NULL) free(fs); return p; }
/* Parameter constructor: specified the shader file path*/ ShaderProgram::ShaderProgram(const GLchar * vertex_file_path,const GLchar * fragment_file_path) :m_uiProgramID(-1) ,m_invalidated(false) ,m_vertexShaderFile(vertex_file_path) ,m_fragmentShaderFile(fragment_file_path) ,m_isCompiled(false) ,m_vertexShaderHandle(-1) ,m_fragmentShaderHandle(-1) ,m_uniformNames(NULL) ,m_iUniformLocation(NULL) ,m_attributeNames(NULL) ,m_iAttributeLocation(NULL) { compileShaders(m_vertexShaderFile,m_fragmentShaderFile); if (isCompiled()) { fetchAttributes(); fetchUniforms(); addManagedShader(); } }
void GLWidget::startGlutLoop() { glClearColor(0.0f/*.84*/, 0.0f/*.84*/, 0.0f/*.84*/, 0.0f); char* version = (char*)glGetString(GL_VERSION); fprintf(stdout, "Version: '%s'\n", version); /** * Create vertex buffer: glGenBuffers, glBindBuffer, glBufferData. */ createVertexBuffer(); /** * Read shaders from file, compile, verify and add to shader program. */ compileShaders(); /** * Start the rendering loop. */ glutMainLoop(); }
int main(int argc, char ** argv) { initGlutAndCreateWindow(argc, argv); initGlew(); // compile and link shader programs, also sets program global variable openGLProgramObject = compileShaders(); // get location/handle for coord variable in the vertex shader coordAttribute = getAttributeLocation("coord"); // set the render function to continually call in the main loop glutDisplayFunc(render); // glClearColor only sets state, does not actually clear anything glClearColor(1.0f, 0.0f, 0.0f, 1.0f); // done with setup, now constantly loop and call render function glutMainLoop(); return 1; }
Program::Program(bool useNormals/*=false*/, bool useColors/*=false*/, bool useTextures/*=false*/) { needsNormals = useNormals; needsColors = useColors; needsTextures = useTextures; light=NULL; view=NULL; projection=NULL; if (compileShaders()) { //continue to find locations necessary if(loadLocations()) { //success, what else do we need to do? } else { std::cerr<<"Failed to locate value in program."<<std::endl; exit(EXIT_FAILURE); } } else { //error std::cerr<<"Failed to compile shaders for program."<<std::endl; exit(EXIT_FAILURE); } }
/*Non-parameter constructor:use the default shader*/ ShaderProgram::ShaderProgram() :m_uiProgramID(-1) ,m_invalidated(false) ,m_vertexShaderFile("VertexShader.glsl") ,m_fragmentShaderFile("FragmentShader.glsl") ,m_isCompiled(false) ,m_vertexShaderHandle(-1) ,m_fragmentShaderHandle(-1) ,m_uniformNames(NULL) ,m_iUniformLocation(NULL) ,m_attributeNames(NULL) ,m_iAttributeLocation(NULL) ,m_iAttributeSize(0) ,m_iUniformSize(0) { compileShaders(m_vertexShaderFile,m_fragmentShaderFile); if (isCompiled()) { fetchAttributes(); fetchUniforms(); addManagedShader(); } }
SpriteRender::SpriteRender(GLuint pos, GLuint col, int n, CL* cli, RTPSSettings* _settings):Render(pos,col,n,cli,_settings) { string path(GLSL_SOURCE_DIR); string filename = settings->GetSettingAs<string>("render_texture"); //path += "../../../sprites/fsu_seal.jpg"; //path += "../../../sprites/firejet_blast.png"; //borrowed from http://homepage.mac.com/nephilim/sw3ddev/additive_blending.html path = "../../sprites/" + filename; //path += "../../../sprites/firejet_smoke.png"; //path += "../../../sprites/tomek.jpg"; //path += "../../../sprites/enjalot.jpg"; printf("LOAD TEXTURE!!!!!!!!!!!!!!\n"); printf("filename: %s\n", filename.c_str()); printf("path: %s\n", path.c_str()); settings->printSettings(); loadTexture(path, "texture"); //string vert(GLSL_BIN_DIR); //string frag(GLSL_BIN_DIR); //vert+="/sphere_vert.glsl"; //frag+="/sphere_tex_frag.glsl"; string vert = shader_source_dir + "/sprite_vert.glsl"; string frag = shader_source_dir + "/" + settings->GetSettingAs<string>("render_frag_shader"); glsl_program[SPHERE_SHADER] = compileShaders(vert.c_str(),frag.c_str()); }
int main() { sf::RenderWindow mainWindow( sf::VideoMode( 640, 480 ), "ne0ndrag0n area51 - SFML & OpenGL Training", sf::Style::Close ); mainWindow.setVerticalSyncEnabled( true ); // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions glewExperimental = GL_TRUE; // Initialize GLEW to setup the OpenGL Function pointers glewInit(); GLuint program = compileShaders(); glViewport( 0, 0, 640, 480 ); GLfloat vertices[] = { 0.5f, 0.5f, 0.0f, // Top Right 0.5f, -0.5f, 0.0f, // Bottom Right -0.5f, -0.5f, 0.0f, // Bottom Left -0.5f, 0.5f, 0.0f // Top Left }; GLuint indicies[] = { 0, 1, 3, 1, 2, 3 }; GLuint VBO, VAO, EBO; glGenVertexArrays( 1, &VAO ); glGenBuffers( 1, &VBO ); glGenBuffers( 1, &EBO ); glBindVertexArray( VAO ); glBindBuffer( GL_ARRAY_BUFFER, VBO ); glBufferData( GL_ARRAY_BUFFER, sizeof( vertices ), vertices, GL_STATIC_DRAW ); glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof( GLfloat ), ( GLvoid* ) 0 ); glEnableVertexAttribArray( 0 ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO ); glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( indicies ), indicies, GL_STATIC_DRAW ); glBindVertexArray( 0 ); while( mainWindow.isOpen() ) { mainWindow.clear( sf::Color::Black ); glUseProgram( program ); glBindVertexArray( VAO ); glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0 ); glBindVertexArray( 0 ); mainWindow.display(); sf::Event event; while( mainWindow.pollEvent( event ) ) { if( event.type == sf::Event::Closed ) { mainWindow.close(); glDeleteVertexArrays( 1, &VAO ); glDeleteBuffers( 1, &VBO ); } } } return 0; }
KawaiiGL::KawaiiGL(QWidget *parent) : QMainWindow(parent), m_kView(NULL), m_edDlg(NULL), m_doc(NULL) { ui.setupUi(this); m_sett.loadFromReg(); connect(&m_sett, SIGNAL(changed()), &m_sett, SLOT(storeToReg())); setWindowTitle("KawaiiGL"); show(); // needed becase we're creating display lists in the c'tor. QDir::setCurrent(EXAMPLES_DIR); // we're reading the config and textures from there m_progMenu = new QMenu(this); m_modelsMenu = new QMenu(this); m_doc = new Document(this); // adds to the menus m_progMenu->addSeparator(); QAction *loadFromFileAct = m_progMenu->addAction("From file..."); connect(loadFromFileAct, SIGNAL(triggered(bool)), m_doc, SLOT(loadProgramFile())); m_kView = new T2GLWidget(this, m_doc); setCentralWidget(m_kView); m_edDlg = new KwEdit(this, m_sett.disp, m_doc, m_kView); // need the view for tracking vec2s m_edDlg->show(); m_edDlg->move(pos() + QPoint(width() - 20, 30)); m_control = new MyDialog(this); QBoxLayout *control_l = new QVBoxLayout(); m_control->setLayout(control_l); control_l->setMargin(0); control_l->setSpacing(0); QTabWidget *tabs = new QTabWidget(); control_l->addWidget(tabs); m_contDlg = new ControlPanel(&m_sett.disp, this, m_doc, m_kView); tabs->addTab(m_contDlg, "Config"); m_browse = new ProjBrowser(this, m_doc); tabs->addTab(m_browse, "Browser"); tabs->setCurrentWidget(m_browse); //tabs->setCurrentIndex(m_sett.gui.configWindowTab); tabs->setCurrentIndex(0); m_control->show(); m_control->move(pos() + QPoint(-30, 20)); m_control->resize(100, 100); // make it as small as possible m_doc->model()->m_errAct = new ErrorHighlight(m_edDlg); connect(m_kView, SIGNAL(message(const QString&)), this, SLOT(message(const QString&))); connect(m_edDlg, SIGNAL(changedModel(DocSrc*)), m_doc, SLOT(calc(DocSrc*))); connect(m_edDlg, SIGNAL(updateShaders()), m_doc, SLOT(compileShaders())); // connect(m_kView, SIGNAL(decompProgChanged(const QString&)), m_edDlg, SLOT(curChanged(const QString&))); connect(m_doc, SIGNAL(loaded()), m_kView, SLOT(newModelLoaded())); //connect(m_doc, SIGNAL(loaded()), m_edDlg, SLOT(doVarsUpdate())); // parsed new text. vars defs may be wrong connect(m_doc, SIGNAL(modelChanged()), m_kView, SLOT(updateGL())); connect(m_doc, SIGNAL(progChanged()), m_kView, SLOT(redoFrameBuffers())); connect(m_kView, SIGNAL(changedFBOs()), m_contDlg, SLOT(updateTexEdits())); connect(m_kView, SIGNAL(makeGradientTex(int, const QString&)), m_contDlg, SLOT(externalGradient(int, const QString&))); connect(m_doc, SIGNAL(progParamChanged()), m_kView, SLOT(updateGL())); connect(m_doc, SIGNAL(addModelLine(const QString&)), m_edDlg, SLOT(addModelLine(const QString&))); connect(m_contDlg, SIGNAL(changedRend()), m_doc, SLOT(calcNoParse())); // passes update connect(m_contDlg, SIGNAL(changedFont()), m_kView, SLOT(updateCoordFont())); connect(m_contDlg, SIGNAL(doUpdate()), m_kView, SLOT(updateGL())); // passes update connect(m_contDlg, SIGNAL(resetView()), m_kView, SLOT(resetState())); connect(m_contDlg, SIGNAL(resetLight()), m_kView, SLOT(resetLight())); connect(m_contDlg, SIGNAL(changedTexFile(int)), m_kView, SLOT(setTexture(int))); // connect(m_contDlg, SIGNAL(reassertTex(int)), m_kView, SLOT(rebindTexture(int))); connect(m_contDlg, SIGNAL(saveMesh()), m_doc, SLOT(calcSave())); connect(m_browse, SIGNAL(openDocText(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) ); connect(m_browse, SIGNAL(openPassConf(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) ); connect(m_browse, SIGNAL(commitGuiData()), m_edDlg, SLOT(commitAll())); connect(m_doc, SIGNAL(goingToClearProg()), m_edDlg, SLOT(clearingProg())); connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_edDlg, SLOT(readProg(ProgKeep*)) ); connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_browse, SLOT(readProg(ProgKeep*)) ); connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_browse, SLOT(readModel()) ); connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_edDlg, SLOT(readModel(DocSrc*))); connect(&m_sett.disp.bVtxNormals, SIGNAL(changed()), m_doc, SLOT(calcNoParse())); // TBD - this is bad. connect(m_contDlg->ui.clipSlider, SIGNAL(valueChanged(int)), m_kView, SLOT(setClipValue(int))); m_kView->setContextMenuPolicy(Qt::ActionsContextMenu); QPushButton *viewBot = new QPushButton("View"); viewBot->setMaximumSize(60, 19); statusBar()->addPermanentWidget(viewBot); QMenu *view = new QMenu("View"); viewBot->setMenu(view); QPushButton *fpsBot = new QPushButton(QIcon(":/images/arrow-circle.png"), QString()); fpsBot->setMaximumSize(20, 19); statusBar()->addPermanentWidget(fpsBot); (new CheckBoxIn(&m_sett.disp.fullFps, fpsBot))->reload(); QCheckBox *vSyncBox = new QCheckBox("vSync"); vSyncBox->setMaximumHeight(19); statusBar()->addPermanentWidget(vSyncBox); (new CheckBoxIn(&m_sett.disp.vSync, vSyncBox))->reload(); QAction *confVis = new QAction("Display", view); view->addAction(confVis); m_control->connectAction(confVis); QAction *editVis = new QAction("Edit", view); view->addAction(editVis); m_edDlg->connectAction(editVis); m_kView->connectedInit(); processCmdArgs(); }
ForwardProgram::ForwardProgram(const std::string& vertexPath, const std::string& fragmentPath, const std::string& geometryPath) : ShaderProgram() { compileShaders(vertexPath, fragmentPath, geometryPath); glUseProgram(mProgramID); glUseProgram(0); }
GLuint ShaderUtil::compileShaders(std::string name){ return compileShaders(name +".vert",name + ".frag"); }
void Background::setShaders() { program = compileShaders("./shaders/background.vert.glsl", "./shaders/background.frag.glsl"); }
void Tutorial::Run() { #ifdef __TUT_VERSION #if __TUT_VERSION >= 17 if (_tutorialID >= 17) { char windowName[255]; sprintf(&windowName[0], "Tutorial %d", _tutorialID); if (!GLUTBackendCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, false, windowName)) { return; } #if __TUT_VERSION == 17 _tutorial = new Tutorial17(); #elif __TUT_VERSION == 18 _tutorial = new Tutorial18(); #elif __TUT_VERSION == 19 _tutorial = new Tutorial19(); #elif __TUT_VERSION == 20 _tutorial = new Tutorial20(); #elif __TUT_VERSION == 21 _tutorial = new Tutorial21(); #elif __TUT_VERSION == 22 _tutorial = new Tutorial22(); #elif __TUT_VERSION == 23 _tutorial = new Tutorial23(); #endif if (!_tutorial->Init(pVSFileName, pFSFileName)) { return; } char* version = (char*)glGetString(GL_VERSION); fprintf(stdout, "Version: '%s'\n", version); _tutorial->Run(); delete _tutorial; return; } #endif #endif initGlut(); initGlew(); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); if (_tutorialID == 16) { glFrontFace(GL_CW); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); } char* version = (char*)glGetString(GL_VERSION); fprintf(stdout, "Version: '%s'\n", version); /// /// Create vertex buffer: glGenBuffers, glBindBuffer, glBufferData. /// createVertexBuffer(); /// /// Create the index buffer: glGenBuffers, glBindBuffer, glBufferData. /// createIndexBuffer(); /// /// Read shaders from file, compile, verify and add to shader program. /// compileShaders(); if (_tutorialID == 16) { glUniform1i(_gSampler, 0); _pTexture = new Texture(GL_TEXTURE_2D, "/home/lparkin/Projects/S3/OpenGlDirsProject/LearnOpenGL-nonQt/Project/Content/test.png"); if (!_pTexture->Load()) { exit(1); } } /// /// Setup the perspective projection information. /// _gPersProjInfo.FOV = 60.0f; _gPersProjInfo.Height = WINDOW_HEIGHT_1_14; _gPersProjInfo.Width = WINDOW_WIDTH_1_14; _gPersProjInfo.zNear = 1.0f; _gPersProjInfo.zFar = 100.0f; /// /// Start the rendering loop. /// glutMainLoop(); }
void GpuProgramManager::compileAllShaders(bool p_ForceRecompile, bool p_UpdateResources) { compileShaders(_activeRefs, p_ForceRecompile, p_UpdateResources); }
bool Shadertoy::loadFromFile() { auto vSource = loadFile("shaders/s.vert"); auto fSource = loadFile("shaders/s.frag"); return compileShaders(vSource, fSource); }
void Application::create() { compileShaders(); int dim = static_cast<int>(glm::ceil(glm::sqrt(NUM_FRAME_BUFFERS))); for (int idx = 0; idx < NUM_FRAME_BUFFERS; idx++){ float width = 400.0f; glm::vec3 offset((idx % dim) / static_cast<float>(dim), 0.0f, idx / static_cast<float>(dim)); glm::float32 offset_scale = 20.0f; PlyDataReader::getSingletonPtr()->renew(); #define PORSCHE #ifdef PORSCHE PlyDataReader::getSingletonPtr()->readDataInfo("big_porsche.ply", nullptr, 0); #else PlyDataReader::getSingletonPtr()->readDataInfo("happy.ply", nullptr, 0); #endif unsigned int nVertices = PlyDataReader::getSingletonPtr()->getNumVertices(); unsigned int nFaces = PlyDataReader::getSingletonPtr()->getNumFaces(); //#define GROUND #ifdef GROUND vertices[idx].resize(nVertices + 4); indices[idx].resize(nFaces * 3 + 6); #else vertices[idx].resize(nVertices); indices[idx].resize(nFaces * 3); #endif PlyDataReader::getSingletonPtr()->readData(vertices[idx].data(), indices[idx].data()); glm::vec3 center; glm::float32 min_y = vertices[idx][0].pos.y; size_t i = 0; for (; i < vertices[idx].size() - 4; i++) { center += vertices[idx][i].pos + offset_scale * offset; min_y = glm::min(min_y, vertices[idx][i].pos.y); } center /= vertices[idx].size(); #ifdef GROUND vertices[idx][nVertices + 0].pos = glm::vec3(-width, min_y, -width) + offset_scale * offset; vertices[idx][nVertices + 0].normal = glm::vec3(0, 1, 0); vertices[idx][nVertices + 1].pos = glm::vec3(-width, min_y, width) + offset_scale * offset; vertices[idx][nVertices + 1].normal = glm::vec3(0, 1, 0); vertices[idx][nVertices + 2].pos = glm::vec3(width, min_y, -width) + offset_scale * offset; vertices[idx][nVertices + 2].normal = glm::vec3(0, 1, 0); vertices[idx][nVertices + 3].pos = glm::vec3(width, min_y, width) + offset_scale * offset; vertices[idx][nVertices + 3].normal = glm::vec3(0, 1, 0); indices[idx][3 * nFaces + 0] = nVertices + 0; indices[idx][3 * nFaces + 1] = nVertices + 1; indices[idx][3 * nFaces + 2] = nVertices + 2; indices[idx][3 * nFaces + 3] = nVertices + 2; indices[idx][3 * nFaces + 4] = nVertices + 1; indices[idx][3 * nFaces + 5] = nVertices + 3; #endif for (size_t i = 0; i < vertices[idx].size(); i++) { vertices[idx][i].pos -= center; } for (size_t i = 0; i < vertices[idx].size(); i++) { //vertices[i].pos *= 30.0; #ifdef PORSCHE vertices[idx][i].pos *= 0.4; #else vertices[i].pos *= 1.0; #endif } glGenBuffers(1, &vertices_buffer[idx]); glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer[idx]); glBufferData(GL_ARRAY_BUFFER, vertices[idx].size() * sizeof(PlyObjVertex), vertices[idx].data(), GL_STATIC_DRAW); glGenBuffers(1, &indices_buffer[idx]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer[idx]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices[idx].size() * sizeof(unsigned int), indices[idx].data(), GL_STATIC_DRAW); } }
void Shader::compileAndLink(const GLchar *vertexSource, const GLchar *fragmentSource ) { compileShaders(vertexSource, fragmentSource); linkProgram(); }
int main() { GLsizei multiSamples = 8; GLFWwindow* window = initWindow(); if (window == nullptr) { std::cout << "Unable to initialize window." << std::endl; return -1; } // Start the timer GLfloat deltaTime, lastFrame, currentFrame; lastFrame = 0.0f; currentFrame = 0.0f; // Setup the viewport; GLfloat screenWidth = 800, screenHeight = 600; glViewport(0, 0, screenWidth, screenHeight); // Setup Camera Camera cam = initCamera(); glfwSetWindowUserPointer(window, &cam); // Load Models Model planet = Model("./Models/planet/planet.obj"); Model asteroid = Model("./Models/rock/rock.obj"); // Load and Compile Shaders GLuint program = compileShaders("../OpenGL3-3/shaders/advanced/instance/basic.vert.glsl", "../OpenGL3-3/shaders/advanced/instance/basic.frag.glsl"); GLuint modelShader = compileShaders("../OpenGL3-3/shaders/newModel/model.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl"); GLuint instancedModelShader = compileShaders("../OpenGL3-3/shaders/newModel/imodel.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl"); GLuint frameBufferShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl"); // Setup MVP model glm::mat4 model, view, proj; view = cam.GetViewMatrix(); proj = glm::perspective(glm::radians(45.0f), (float)screenWidth / (float)screenHeight, 0.1f, 1000.0f); #pragma region quad GLfloat quadVertices[] = { // Positions // Colors -0.05f, 0.05f, 1.0f, 0.0f, 0.0f, 0.05f, -0.05f, 0.0f, 1.0f, 0.0f, -0.05f, -0.05f, 0.0f, 0.0f, 1.0f, -0.05f, 0.05f, 1.0f, 0.0f, 0.0f, 0.05f, -0.05f, 0.0f, 1.0f, 0.0f, 0.05f, 0.05f, 0.0f, 1.0f, 1.0f }; glm::vec2 translations[100]; int index = 0; GLfloat offset = 0.1f; for (GLint y = -10; y < 10; y += 2) { for (GLint x = -10; x < 10; x += 2) { glm::vec2 translation; translation.x = (GLfloat)x / 10.0f + offset; translation.y = (GLfloat)y / 10.0f + offset; translations[index++] = translation; } } GLfloat fboQuad[] = { -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f }; #pragma endregion GLuint VBO, VAO, instanceVBO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glGenBuffers(1, &instanceVBO); glBindBuffer(GL_ARRAY_BUFFER, instanceVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); // Create the Framebuffer GLuint FBO; glGenFramebuffers(1, &FBO); glBindFramebuffer(GL_FRAMEBUFFER, FBO); GLuint texture; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture); glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, multiSamples, GL_RGB, screenWidth, screenHeight, GL_TRUE);// , GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, texture, 0); GLuint sampleRBO; glGenRenderbuffers(1, &sampleRBO); glBindRenderbuffer(GL_RENDERBUFFER, sampleRBO); glRenderbufferStorageMultisample(GL_RENDERBUFFER, multiSamples, GL_DEPTH24_STENCIL8, screenWidth, screenHeight); glBindRenderbuffer(GL_RENDERBUFFER, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, sampleRBO); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "FRAMEBUFFER INCOMPLETE!" << std::endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); GLuint regularFBO; glGenFramebuffers(1, ®ularFBO); glBindFramebuffer(GL_FRAMEBUFFER, regularFBO); GLuint tex; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "FRAMEBUFFER 2 INCOMPLETE!" << std::endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); GLuint fboVAO, fboVBO; glGenVertexArrays(1, &fboVAO); glGenBuffers(1, &fboVBO); glBindVertexArray(fboVAO); glBindBuffer(GL_ARRAY_BUFFER, fboVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(fboQuad), fboQuad, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2*sizeof(GLfloat))); glBindVertexArray(0); glBindVertexArray(VAO); { glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)(sizeof(GLfloat) * 2)); glEnableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, instanceVBO); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0); glBindBuffer(GL_ARRAY_BUFFER, 0); glVertexAttribDivisor(2, 1); } glBindVertexArray(0); std::cout << sizeof(glm::mat4) << std::endl; const int amount = 100000; glm::mat4* modelMats; modelMats = new glm::mat4[amount]; srand(glfwGetTime()); GLfloat radius = 150.0f; offset = 25.0f; for (GLuint i = 0; i < amount; i++) { glm::mat4 model; GLfloat angle = (GLfloat)i / (GLfloat)amount * 360.0f; GLfloat displacement = (rand() % (GLint)(2 * offset)) / 100.0f - offset; GLfloat x = sin(angle) * radius + displacement; displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset; GLfloat y = displacement * 0.4f; displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset; GLfloat z = cos(angle) * radius + displacement; model = glm::translate(model, glm::vec3(x, y, z)); GLfloat scale = (rand() % 20) / 100.0f + 0.05f; model = glm::scale(model, glm::vec3(scale)); GLfloat rotAngle = (rand() % 360); model = glm::rotate(model, rotAngle, glm::vec3(0.4f, 0.6f, 0.8f)); modelMats[i] = model; } for (GLuint i = 0; i < asteroid.meshes.size(); i++) { GLuint VAO = asteroid.meshes[i].VAO; GLuint buffer; glBindVertexArray(VAO); glGenBuffers(1, &buffer); glBindBuffer(GL_ARRAY_BUFFER, buffer); glBufferData(GL_ARRAY_BUFFER, amount * sizeof(glm::mat4), &modelMats[0], GL_STATIC_DRAW); GLsizei vec4Size = sizeof(glm::vec4); glEnableVertexAttribArray(3); glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)0); glEnableVertexAttribArray(4); glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(vec4Size)); glEnableVertexAttribArray(5); glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(2 * vec4Size)); glEnableVertexAttribArray(6); glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(3 * vec4Size)); glVertexAttribDivisor(3, 1); glVertexAttribDivisor(4, 1); glVertexAttribDivisor(5, 1); glVertexAttribDivisor(6, 1); glBindVertexArray(0); } glUseProgram(modelShader); glUniformMatrix4fv(glGetUniformLocation(modelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj)); glUseProgram(instancedModelShader); glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj)); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; glBindFramebuffer(GL_FRAMEBUFFER, FBO); glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); handleMovement(window, deltaTime); glUseProgram(instancedModelShader); glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix())); glUseProgram(modelShader); glUniformMatrix4fv(glGetUniformLocation(modelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix())); glm::mat4 model; model = glm::translate(model, glm::vec3(0.0f, -5.0f, 0.0f)); model = glm::scale(model, glm::vec3(4.0f)); glUniformMatrix4fv(glGetUniformLocation(modelShader, "model"), 1, GL_FALSE, glm::value_ptr(model)); planet.draw(modelShader); glUseProgram(instancedModelShader); glBindTexture(GL_TEXTURE_2D, asteroid.textures_loaded[0].id); for (GLuint i = 0; i < asteroid.meshes.size(); i++) { glBindVertexArray(asteroid.meshes[i].VAO); glDrawElementsInstanced(GL_TRIANGLES, asteroid.meshes[i].vertices.size(), GL_UNSIGNED_INT, 0, amount); glBindVertexArray(0); } glBindTexture(GL_TEXTURE_2D, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, FBO); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, regularFBO); glBlitFramebuffer(0, 0, screenWidth, screenHeight, 0, 0, screenWidth, screenHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST); glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_DEPTH_TEST); glUseProgram(frameBufferShader); glBindVertexArray(fboVAO); glBindTexture(GL_TEXTURE_2D, tex); //glUniform1i(glGetUniformLocation(frameBufferShader, "myTexture"), 0); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); glBindTexture(GL_TEXTURE_2D, 0); glfwSwapBuffers(window); } glfwTerminate(); return 0; }