bool GLSLProgram::load(const std::string& vertFilePath, const std::string& fragFilePath) { // Have OpenGL create the shaders _vertexShader = glCreateShader(GL_VERTEX_SHADER); if (_vertexShader == 0) { Error::getInstance().fail(ErrorCodes::FAILED_TO_CREATE_SHADER); return false; } _fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if (_fragmentShader == 0) { Error::getInstance().fail(ErrorCodes::FAILED_TO_CREATE_SHADER); return false; } std::vector<unsigned char> vertFileContents; std::vector<unsigned char> fragFileContents; IOManager::getInstance().readTextFileToBuffer(vertFilePath, vertFileContents); IOManager::getInstance().readTextFileToBuffer(fragFilePath, fragFileContents); loadShaderSource(_vertexShader, (const char*)&(vertFileContents[0])); loadShaderSource(_fragmentShader, (const char*)&(fragFileContents[0])); if (compile()) { addAttribute("vertexPos"); addAttribute("vertexColor"); addAttribute("vertexUV"); return link(); } else { return false; } }
GLuint createAndLoadFragmentShaderAll() { const GLuint shader_handle = createFragmentShader(); if (shader_handle == 0){ return 0; } { const char* shader_source_file_path_list[] = { SHADER_SOURCE_BASE_PATH "circle.frag" }; const int shader_source_file_num = countof(shader_source_file_path_list); const GLchar** shader_source_file_list = loadShaderSource(shader_source_file_num, shader_source_file_path_list); if (shader_source_file_list) { glShaderSource(shader_handle, shader_source_file_num, shader_source_file_list, NULL); freeShaderSource(shader_source_file_num, shader_source_file_list); shader_source_file_list = NULL; } } { glCompileShader(shader_handle); { const GLint shader_compile_result = getShaderResult(shader_handle, GL_COMPILE_STATUS); if (shader_compile_result == GL_FALSE){ return 0; } } } return shader_handle; }
// loads a source file and directly compiles it to a shader of 'shaderType' // GLuint loadShaderFile(const char* fileName, GLenum shaderType) { GLuint shader = glCreateShader(shaderType); // check if operation failed // if (shader == 0) { std::cout << "(loadShaderFile) - Could not create shader." << std::endl; return 0; } // load source code from file // const char* shaderSrc = loadShaderSource(fileName); if (shaderSrc == NULL) return 0; // pass source code to new shader object // glShaderSource(shader, 1, (const char**)&shaderSrc, NULL); delete[] shaderSrc; // compile shader // glCompileShader(shader); // log compile messages, if any // int logMaxLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logMaxLength); char log[logMaxLength]; int logLength = 0; glGetShaderInfoLog(shader, logMaxLength, &logLength, log); if (logLength > 0) { std::cout << "(loadShaderFile) - Compiler log:\n------------------\n" << log << "\n------------------" << std::endl; } // return compiled shader (may have compiled WITH errors) // return shader; }
Shader::Shader(const char* vertPath, const char* fragPath) { error = false; vertShader = glCreateShader(GL_VERTEX_SHADER); fragShader = glCreateShader(GL_FRAGMENT_SHADER); unsigned long vertSourceLength = 0; GLchar * vertShaderSource[1]; int vertSourceFetchErr = loadShaderSource(vertPath, vertShaderSource, vertSourceLength); unsigned long fragSourceLength; GLchar * fragShaderSource[1]; int fragSourceFetchErr = loadShaderSource(fragPath, fragShaderSource, fragSourceLength); error = (vertSourceFetchErr != 0) || (fragSourceFetchErr != 0); if (error) { errorLog = "ERROR while reading shader files"; return; } glShaderSource(vertShader, 1, vertShaderSource, NULL); glShaderSource(fragShader, 1, fragShaderSource, NULL); glCompileShader(vertShader); error = !testCompileStatus(vertShader); if (error) return; glCompileShader(fragShader); error = !testCompileStatus(fragShader); if (error) return; program = glCreateProgram(); glAttachShader(program, vertShader); glAttachShader(program, fragShader); glLinkProgram(program); error = !testLinkStatus(program); if (error)return; glDetachShader(program, vertShader); glDetachShader(program, fragShader); glDeleteShader(vertShader); glDeleteShader(fragShader); }
TEST(ShaderLib,failLink) { constexpr auto *shaderName="Test5"; auto shader = ngl::ShaderLib::instance(); shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF); constexpr auto Vertex="Test5Vert"; shader->attachShader( Vertex, ngl::ShaderType::VERTEX ); shader->loadShaderSource(Vertex,"files/vertLinkErr.glsl"); EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader"; constexpr auto Fragment="Test5Frag"; shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT ); shader->loadShaderSource(Fragment,"files/fragLinkErr.glsl"); EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader"; shader->attachShaderToProgram(shaderName,Vertex); shader->attachShaderToProgram(shaderName,Fragment); EXPECT_FALSE(shader->linkProgramObject(shaderName))<<"This should not link as in and out don't match"; }
TEST(ShaderLib,loadPartsFailFragment) { auto shader = ngl::ShaderLib::instance(); shader->createShaderProgram("Test4",ngl::ErrorExit::OFF); constexpr auto Fragment="Test4Frag"; shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT ,ngl::ErrorExit::OFF); shader->loadShaderSource(Fragment,"files/fragErr.glsl"); EXPECT_FALSE(shader->compileShader(Fragment))<<"error compiling vert shader"; }
bool ShaderProgram::addFragmentShader(aftfs::FileSystem &fileSystem, const std::string &path) { std::string source = loadShaderSource(fileSystem, path); if (source.empty()) { return false; } return createShader(m_attachedShaders, source, GL_FRAGMENT_SHADER, m_program); }
ShaderObject::ShaderObject(char *vertexfile, char *fragmentfile) { printf("%s %s\n", vertexfile, fragmentfile); program = glCreateProgram(); vertexShader = glCreateShader(GL_VERTEX_SHADER); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); char** vertexShaderSource = loadShaderSource(vertexfile); char** fragmentShaderSource = loadShaderSource(fragmentfile); glShaderSource(vertexShader, 1, vertexShaderSource, NULL); glShaderSource(fragmentShader, 1, fragmentShaderSource, NULL); freeShaderSource(vertexShaderSource); freeShaderSource(fragmentShaderSource); glCompileShader(vertexShader); glCompileShader(fragmentShader); shaderLog(vertexShader); shaderLog(fragmentShader); glAttachShader(program, vertexShader); glAttachShader(program, fragmentShader); glLinkProgram(program); }
TEST(ShaderLib,loadPartsFailVertex) { auto shader = ngl::ShaderLib::instance(); shader->createShaderProgram("Test3",ngl::ErrorExit::OFF); constexpr auto Vertex="Test3Vert"; shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF); shader->loadShaderSource(Vertex,"files/vertErr.glsl"); EXPECT_FALSE(shader->compileShader(Vertex))<<"error compiling vert shader"; }
/** * * @param vert Path to vertex shader * @param frag Path to fragment shader */ ShaderPtr loadShader( QString vert, QString frag ) { qDebug() << "loadShader("<< vert << "|" << frag << ")"; ShaderPtr program = std::make_shared<Shader>(); QByteArray defs = "#define USE_DESKTOP_BLEND " #ifdef USE_DESKTOP_BLEND "1" #else "0" #endif ; if( !program->addShaderFromSourceCode( QGLShader::Vertex, loadShaderSource(vert, defs) ) ) { qWarning() << "Failed to load vertex shader (" << vert << ")\n" << program->log(); return ShaderPtr(); } if( !program->addShaderFromSourceCode( QGLShader::Fragment, loadShaderSource(frag, defs) ) ) { qWarning() << "Failed to load fragment shader (" << frag << ")\n" << program->log(); return ShaderPtr(); } if( !program->link() ) { qWarning() << "Failed to link shader (" << vert << "|" << frag << ")\n" << program->log(); return ShaderPtr(); } return program; }
bool Shader::loadFromFile(const Shader::Type type, const std::string& filename) { if(p_shader_id != 0) { glDeleteShader(p_shader_id); } std::string shader_source; if(!loadShaderSource(filename, shader_source)) { return false; } loadFromSource(type, shader_source); return true; }
void loadShader(Midori::Shader* shader, const std::string& vertex, const std::string& fragment) { shader->vertexShader = glCreateShader(GL_VERTEX_SHADER); shader->fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); shader->id = glCreateProgram(); const char* vertexShaderSource = loadShaderSource(vertex.c_str()); const char* fragmentShaderSource = loadShaderSource(fragment.c_str()); if(vertexShaderSource == nullptr || fragmentShaderSource == nullptr) cerr << " Shader loading error " << vertex << " " << fragment << cerr; glShaderSource(shader->vertexShader,1,&vertexShaderSource,0); glShaderSource(shader->fragmentShader,1,&fragmentShaderSource,0); glCompileShader(shader->vertexShader); glCompileShader(shader->fragmentShader); glAttachShader(shader->id,shader->vertexShader); glAttachShader(shader->id,shader->fragmentShader); glLinkProgram(shader->id); delete vertexShaderSource; delete fragmentShaderSource; }
TEST(ShaderLib,editShader) { auto shader = ngl::ShaderLib::instance(); auto *shaderName="Edit"; shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF); constexpr auto Vertex="EditVert"; shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF); shader->loadShaderSource(Vertex,"files/EditVert.glsl"); EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe "; EXPECT_TRUE(shader->editShader(Vertex,"@numLights","2"))<<"edit shader"; EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader"; constexpr auto Fragment="EditFrag"; shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT,ngl::ErrorExit::OFF ); shader->loadShaderSource(Fragment,"files/EditFrag.glsl"); EXPECT_TRUE(shader->editShader(Fragment,"@numLights","2"))<<"edit shader"; EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader"; shader->attachShaderToProgram(shaderName,Vertex); shader->attachShaderToProgram(shaderName,Fragment); EXPECT_TRUE(shader->linkProgramObject(shaderName))<<"First Link"; (*shader)[shaderName]->use(); EXPECT_TRUE(shader->getCurrentShaderName()==shaderName); // Now re-edit shader->resetEdits(Vertex); shader->resetEdits(Fragment); EXPECT_TRUE(shader->editShader(Vertex,"@numLights","5"))<<"edit shader 2nd"; EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe 2nd"; EXPECT_TRUE(shader->editShader(Fragment,"@numLights","5"))<<"edit shader"; EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader"; EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader"; EXPECT_TRUE(shader->linkProgramObject(shaderName)); }
TEST(ShaderLib,loadParts) { auto shader = ngl::ShaderLib::instance(); auto *shaderName="Test2"; shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF); constexpr auto Vertex="Test2Vert"; shader->attachShader( Vertex, ngl::ShaderType::VERTEX ); shader->loadShaderSource(Vertex,"files/vert.glsl"); EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader"; constexpr auto Fragment="Test2Frag"; shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT ); shader->loadShaderSource(Fragment,"files/frag.glsl"); EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader"; shader->attachShaderToProgram(shaderName,Vertex); shader->attachShaderToProgram(shaderName,Fragment); EXPECT_TRUE(shader->linkProgramObject(shaderName)); (*shader)[shaderName]->use(); EXPECT_TRUE(shader->getCurrentShaderName()==shaderName); }
void initShader(){ axesShader = glCreateShader(GL_VERTEX_SHADER); const std::string shaderfile = "cluster.vert"; std::string shadersource; std::cout<<"Reading shader source from file:"<<shaderfile<<std::endl; if ( !loadShaderSource(shaderfile, shadersource) ) { std::cout<<"Failed to load shader:"<<shaderfile<<" quiting!"<<std::endl; exit(1); } std::cout<<"Loaded Shader! Its length is:" << (int)shadersource.size() <<std::endl; GLchar *source = new GLchar[5000]; memcpy(source, shadersource.c_str(), shadersource.size()); int len = strlen(source); // std::cout<<"SHADER SOURCE:\n"<<source<<std::endl; glShaderSource(axesShader, 1, (const GLchar**) &source, (const GLint *) &len); checkGlError(); std::cout<<"Compiling shader!"<<std::endl; glCompileShader(axesShader); checkGlError(); std::cout<<"Creating glProgram"<<std::endl; shaderProg = glCreateProgram(); std::cout<<"\t created with handle:"<<shaderProg<<std::endl; checkGlError(); std::cout<<"\tAttaching Shader"<<std::endl; glAttachShader(shaderProg, axesShader); checkGlError(); std::cout<<"Linking Shader Program"<<std::endl; glLinkProgram(shaderProg); checkGlError(); std::cout<<"DONE!"<<std::endl; }
void SpikeViewer::loadAndCompileShader() { GLuint axesShader = glCreateShader(GL_VERTEX_SHADER); const std::string shaderfile = "cluster.vert"; std::string shadersource; std::cout<<"Reading shader source from file:"<<shaderfile<<std::endl; if ( !loadShaderSource(shaderfile, shadersource) ) { std::cout<<"Failed to load shader:"<<shaderfile<<" quiting!"<<std::endl; exit(1); } const int MAX_SHADER_LEN = 10000; if (shadersource.size()>MAX_SHADER_LEN) { std::cout<<"Shader is too long it cannot be greater than"<<MAX_SHADER_LEN<<std::endl; exit() }
// loads a source file and directly compiles it to a shader of 'shaderType' // GLuint loadShaderFile(const char* fileName, GLenum shaderType) { GLuint shader = glCreateShader(shaderType); // check if operation failed // if (shader == 0) { std::cout << "(loadShaderFile) - Could not create shader." << std::endl; return 0; } // load source code from file // const char* shaderSrc = loadShaderSource(fileName); if (shaderSrc == NULL) return 0; // pass source code to new shader object // glShaderSource(shader, 1, (const char**)&shaderSrc, NULL); delete[] shaderSrc; // compile shader // glCompileShader(shader); // log compile messages, if any // // return compiled shader (may have compiled WITH errors) // return shader; }
void Effect::loadShader(const QGLContext* context) { m_pixelShader = new QGLShader(QGLShader::Fragment); QString source = loadShaderSource(); if(!m_pixelShader->compileSourceCode(source)) { QMessageBox message; message.setText("Failed to compile shader."); message.setInformativeText("Log:\n" + m_pixelShader->log() + "\n\nSource:\n" + source); message.exec(); } m_program = new QGLShaderProgram(context); m_program->addShader(m_pixelShader); if(!m_program->link()) { qDebug("Failed to link program."); //qDebug((const char*)m_program->log().constData()); QString log = m_program->log(); if(log.isNull()) { QMessageBox isNullMsg; isNullMsg.setText("Log is null!"); isNullMsg.exec(); } QMessageBox message; message.setText("Failed to link shader program.\nLog:\n" + log); message.exec(); } // m_loaded = true; }
GLuint Shader::loadShaderCode(const char* fileName, GLenum shaderType) { GLuint shader = glCreateShader(shaderType); if (shader == 0) { return 0; } const char* shaderSrc = loadShaderSource(fileName); if (shaderSrc == NULL) return 0; glShaderSource(shader, 1, (const char**)&shaderSrc, NULL); glCompileShader(shader); int logMaxLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logMaxLength); char log[logMaxLength]; int logLength = 0; glGetShaderInfoLog(shader, logMaxLength, &logLength, log); if (logLength > 0) { std::cout << "(Shader::loadShaderCode) - Compiler log:\n------------------\n" << log << "\n------------------" << std::endl; } return shader; }
int main() { glfwInit(); GLFWwindow* window; window = glfwCreateWindow(800, 600, "TrackballTest", NULL, NULL); glfwMakeContextCurrent(window); // You can set the Trackball camera to another position and give it a name cam.setPosition(glm::vec4(0.0,0.0,10.0,1.0)); cam.setName("TrackballCam"); cam.setNearFar(0.01f, 100.0f); // Set all InputMaps and set one InputMap active iH.setAllInputMaps(cam); iH.changeActiveInputMap("Trackball"); // Callback glfwSetKeyCallback(window, key_callback); glewInit(); // Shader VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert"))); FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/colorShader3D.frag"))); ShaderProgram shader(vs, fs); // Renderer OpenGL3Context context; Renderer renderer(context); // Object Teapot teapot; teapot.loadBufferData(); // getting the start time double startTime = glfwGetTime(); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // You have to compute the delta time cam.setSensitivity(glfwGetTime() - startTime); startTime = glfwGetTime(); shader.bind(); // You have to send the uniform matrices of the Trackball camera to the shader shader.sendMat4("viewMatrix", cam.getViewMatrix()); shader.sendMat4("projectionMatrix", cam.getProjectionMatrix()); teapot.renderGeometry(); shader.unbind(); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); return 0; }
int main() { glfwInit(); Window testWindow(50, 50, WINDOW_WIDTH, WINDOW_HEIGHT, "Deferred Shading"); glfwMakeContextCurrent(testWindow.getWindow()); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // You have to set a camera name cam.setName("PilotviewCam"); cam.setPosition(glm::vec4(0.0, 0.5, 3.0, 1.0)); cam.setNearFar(0.01f, 100.0f); iH.setAllInputMaps(cam); iH.changeActiveInputMap("Pilotview"); //Callback glfwSetKeyCallback(testWindow.getWindow(), key_callback); glewInit(); //our shader VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert"))); FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag"))); ShaderProgram shaderGBuffer(vsGBuffer, fsGBuffer); //load shader here VertexShader vsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.vert"))); FragmentShader fsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.frag"))); ShaderProgram shaderDsLightingShader(vsDsLighting, fsDsLighting); VertexShader vsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.vert"))); FragmentShader fsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.frag"))); ShaderProgram shaderDsCompositingShader(vsDsCompositing, fsDsCompositing); VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag"))); ShaderProgram shaderSFQ(vsSfq, fsSfq); //our renderer OpenGL3Context context; Renderer renderer(context); FBO fboGBuffer(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false); FBO fboDeferredShading(WINDOW_WIDTH, WINDOW_HEIGHT, 3, true, false); FBO fboCompositing(WINDOW_WIDTH, WINDOW_HEIGHT, 3, false, false); //our object Cube cube; Teapot teapot; Rect plane; Rect screenFillingQuad; screenFillingQuad.loadBufferData(); //our textures Texture bricks((char*)RESOURCES_PATH "/bricks_diffuse.png"); Texture bricks_normal((char*)RESOURCES_PATH "/bricks_normal.png"); Texture bricks_height((char*)RESOURCES_PATH "/bricks_height.png"); Texture chrome((char*)RESOURCES_PATH "/chrome.jpg"); Texture cvLogo((char*)RESOURCES_PATH "/cv_logo.bmp"); //Scene creation Level testLevel("testLevel"); Scene testScene("testScene"); testLevel.addScene(&testScene); testLevel.changeScene("testScene"); //Add Camera to scenegraph testScene.getScenegraph()->addCamera(&cam); testScene.getScenegraph()->getCamera("PilotviewCam"); testScene.getScenegraph()->setActiveCamera("PilotviewCam"); Rect rect; Node cube1("cube1"); cube1.addGeometry(&cube); cube1.addTexture(&bricks); cube1.addNormalMap(&bricks_normal); cube1.addHeightMap(&bricks_height); cube1.setModelMatrix(glm::translate(cube1.getModelMatrix(), glm::vec3(-1.0, 0.5, -0.5))); cube1.setModelMatrix(glm::scale(cube1.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7))); Node cube2("cube2"); cube2.addGeometry(&cube); cube2.addTexture(&bricks); cube2.addNormalMap(&bricks_normal); cube2.setModelMatrix(glm::translate(cube2.getModelMatrix(), glm::vec3(-1, 0.5, 0.5))); cube2.setModelMatrix(glm::scale(cube2.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7))); Node cube3("cube3"); cube3.addGeometry(&cube); cube3.addTexture(&bricks); cube3.setModelMatrix(glm::translate(cube3.getModelMatrix(), glm::vec3(0, 0.5, -0.5))); cube3.setModelMatrix(glm::scale(cube3.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7))); Node cube4("cube4"); cube4.addGeometry(&cube); cube4.addTexture(&bricks); cube4.addNormalMap(&bricks_normal); cube4.addHeightMap(&bricks_height,0.07,0.1,true); cube4.setModelMatrix(glm::translate(cube4.getModelMatrix(), glm::vec3(0, 0.5, 0.5))); cube4.setModelMatrix(glm::scale(cube4.getModelMatrix(), glm::vec3(0.7, 0.7, 0.7))); Node wallNode1("wall1"); wallNode1.addGeometry(&plane); wallNode1.addTexture(&cvLogo); wallNode1.setModelMatrix(glm::translate(wallNode1.getModelMatrix(), glm::vec3(0.0, 0.1, 0.2))); wallNode1.setModelMatrix(glm::rotate(wallNode1.getModelMatrix(), 90.0f, glm::vec3(1.0, 0.0, 0.0))); wallNode1.setModelMatrix(glm::scale(wallNode1.getModelMatrix(), glm::vec3(10.5, 10.5, 10.5))); Node teaNode("teaNode"); teaNode.addGeometry(&teapot); teaNode.addTexture(&chrome); teaNode.setModelMatrix(glm::translate(teaNode.getModelMatrix(), glm::vec3(0.2, 0.4, 0.7))); teaNode.setModelMatrix(glm::scale(teaNode.getModelMatrix(), glm::vec3(0.5, 0.5, 0.5))); //Creating a scenegraph testScene.getScenegraph()->getRootNode()->addChildrenNode(&wallNode1); testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube1); testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube2); testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube3); testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube4); //testScene.getScenegraph()->getRootNode()->addChildrenNode(&teaNode); double startTime = glfwGetTime(); //Renderloop //create Light spheres for DS Node lights = Node("Root"); Sphere lightSphere = Sphere(); for (int i = -4; i < 4; i++) for (int j = -4; j < 4; j++) { Node *newLight = new Node(std::string("Node_"+std::to_string(i)+std::to_string(j))); newLight->addGeometry(&lightSphere); newLight->setModelMatrix(glm::translate(glm::mat4(1.0f), glm::vec3(i*1.5, 1.0f, j*1.5))); //newLight.setModelMatrix(glm::translate(glm::mat4(1.0f), glm::vec3(0, 1, 1.0f))); newLight->setModelMatrix(glm::scale(newLight->getModelMatrix(), glm::vec3(2.0, 2.0, 2.0))); lights.addChildrenNode(newLight); } int outputFPS = 0; while (!glfwWindowShouldClose(testWindow.getWindow())) { // You have to compute the delta time float deltaTime = glfwGetTime() - startTime; cam.setSensitivity(deltaTime); //if (!(outputFPS % 20)) //std::cout << "FPS: " << static_cast<int>(1 / (glfwGetTime() - startTime)) << std::endl; std::cout << "FPS: " << static_cast<double>(glfwGetTime() - startTime) * 100 << std::endl; outputFPS++; startTime = glfwGetTime(); //update Model Matrix lights.setModelMatrix(glm::rotate(lights.getModelMatrix(), 10.0f * deltaTime, glm::vec3(0.0, 1.0, 0.0))); fboGBuffer.bind(); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderGBuffer.bind(); shaderGBuffer.sendMat4("viewMatrix", cam.getViewMatrix()); shaderGBuffer.sendMat4("projectionMatrix", cam.getProjectionMatrix()); testScene.render(shaderGBuffer); shaderGBuffer.unbind(); fboGBuffer.unbind(); //DEFERRED SHADING TEIL============================ fboDeferredShading.bind(); glCullFace(GL_FRONT); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderDsLightingShader.bind(); shaderDsLightingShader.sendMat4("viewMatrix", cam.getViewMatrix()); shaderDsLightingShader.sendMat4("projectionMatrix", cam.getProjectionMatrix()); shaderDsLightingShader.sendSampler2D("positionMap", fboGBuffer.getColorTexture(0),0); shaderDsLightingShader.sendSampler2D("normalMap", fboGBuffer.getColorTexture(1),1); shaderDsLightingShader.sendInt("windowWidth", testWindow.getWidth()); shaderDsLightingShader.sendInt("windowHeight", testWindow.getHeight()); shaderDsLightingShader.sendVec3("lightColor", glm::fvec3(0.7f,0.7f,0.4f)); lights.render(shaderDsLightingShader); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); glClearColor(1.0, 1.0, 1.0, 0.0); shaderDsLightingShader.unbind(); fboDeferredShading.unbind(); //COMPOSITING TEIL =============================== fboCompositing.bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderDsCompositingShader.bind(); shaderDsCompositingShader.sendSampler2D("colorMap", fboGBuffer.getColorTexture(2),0); shaderDsCompositingShader.sendSampler2D("lightMap", fboDeferredShading.getColorTexture(2),1); screenFillingQuad.renderGeometry(); shaderDsCompositingShader.unbind(); fboCompositing.unbind(); //================================================ //ScreenFillingQuad Render Pass shaderSFQ.bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (glfwGetKey(testWindow.getWindow(), GLFW_KEY_F1)) shaderSFQ.sendSampler2D("fboTexture", fboDeferredShading.getColorTexture(2)); else shaderSFQ.sendSampler2D("fboTexture", fboCompositing.getColorTexture(2)); screenFillingQuad.renderGeometry(); shaderSFQ.unbind(); glfwSwapBuffers(testWindow.getWindow()); glfwPollEvents(); } glfwDestroyWindow(testWindow.getWindow()); glfwTerminate(); return 0; }
int main() { glfwInit(); GLFWwindow* window; window = glfwCreateWindow(800, 600, "ParticleSystemScene", NULL, NULL); glfwMakeContextCurrent(window); //CAM cam.setKeySpeed(4.0); iH.setAllInputMaps(cam); glfwSetKeyCallback(window, key_callback); cam.setFOV(50); cam.setNearFar(1, 100); glewInit(); //TEXTURES Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png"); Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png"); Texture* smokeBlackTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png"); Texture* smokeBlackTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png"); Texture* snowTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/particle/snowflake.png"); //TODO better Resolution //FINAL EMITTER SNOW Emitter* snow = new Emitter(0, glm::vec3(0.0, 10.0, -5.0), 0.0, 0.166, 100, 30.0, true); snow->setVelocity(0); snow->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 1.0), 0.5f); snow->setAreaEmitting(false, true, 10.0, 10000); snow->addTexture(snowTex, 0.0); snow->defineLook(true, 0.04, 2.0); snow->setMovable(true); //FINAL EMITTER WHITE SMOKE Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 5.0), 0.0, 0.4, 1, 8.0, true); smokeWhite->setVelocity(2); smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f); smokeWhite->addTexture(smokeWhiteTex1, 1.0); smokeWhite->addTexture(smokeWhiteTex2, 0.25); std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.2f }; std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f }; smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 4.0, 4.0, false, 0.3); smokeWhite->switchToGeometryShader(); //FINAL EMITTER BLACK SMOKE Emitter* smokeBlack = new Emitter(0, glm::vec3(0.0, 0.0, -10.0), 0.0, 0.4, 1, 8.0, true); smokeBlack->setVelocity(2); smokeBlack->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f); smokeBlack->addTexture(smokeBlackTex1, 1.0); smokeBlack->addTexture(smokeBlackTex2, 0.08); std::vector<float> smokeBlackSize{ 0.1f, 0.4f, 0.8f, 1.2f }; std::vector<float> smokeBlackTime{ 0.0f, 0.2f, 0.75f, 1.0f }; smokeBlack->defineLook(true, smokeBlackSize, smokeBlackTime, 1.0, 4.0, 4.0, false, 0.3); smokeBlack->switchToGeometryShader(); //PARTICLE SYSTEM Effect* sn = new Effect(); sn->addEmitter(snow); ParticleSystem* psSnow = new ParticleSystem(glm::vec3(0, 2, -5), sn); Node snowNode("snowNode"); snowNode.setParticleActive(true); snowNode.setCamera(&cam); snowNode.addParticleSystem(psSnow); Effect* smWhi = new Effect(); smWhi->addEmitter(smokeWhite); ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(0, 0, 3), smWhi); Node whiteSmokeNode("whiteSmokeNode"); whiteSmokeNode.setParticleActive(true); whiteSmokeNode.setCamera(&cam); whiteSmokeNode.addParticleSystem(psSmokeWhite); Effect* smBla = new Effect(); smBla->addEmitter(smokeBlack); ParticleSystem* psSmokeBlack = new ParticleSystem(glm::vec3(0, 0, -3), smBla); Node blackSmokeNode("blackSmokeNode"); blackSmokeNode.setParticleActive(true); blackSmokeNode.setCamera(&cam); blackSmokeNode.addParticleSystem(psSmokeBlack); // Shader VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert"))); FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag"))); ShaderProgram shader(vs, fs); // Renderer OpenGL3Context context; Renderer renderer(context); // Object Teapot teapot; teapot.loadBufferData(); Node teapotNode("teapotNode"); teapotNode.addGeometry(&teapot); teapotNode.setCamera(&cam); teapotNode.setModelMatrix(glm::translate(teapotNode.getModelMatrix(), glm::vec3(0.0, 0.0, -7.0))); //need scene here mainly because of input Level testLevel("testLevel"); Scene testScene("testScene"); testLevel.addScene(&testScene); testLevel.changeScene("testScene"); //Add Camera to Scene testScene.getScenegraph()->addCamera(&cam); testScene.getScenegraph()->setActiveCamera("Pilotview"); //Set Input-Maps and activate one iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera())); iH.changeActiveInputMap("Pilotview"); //Add Objects to the Scene testScene.getScenegraph()->getRootNode()->addChildrenNode(&teapotNode); testScene.getScenegraph()->getRootNode()->addChildrenNode(&blackSmokeNode); testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode); testScene.getScenegraph()->getRootNode()->addChildrenNode(&snowNode); //start the ParticleSystems psSmokeBlack->start(); psSmokeWhite->start(); psSnow->start(); // getting the start time double startTime = glfwGetTime(); while (!glfwWindowShouldClose(window)) { cam.setSensitivity(glfwGetTime() - startTime); startTime = glfwGetTime(); glEnable(GL_DEPTH); glEnable(GL_DEPTH_TEST); glEnable(GL_BLEND); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shader.bind(); shader.sendMat4("modelMatrix", teapotNode.getModelMatrix()); shader.sendMat4("viewMatrix", cam.getViewMatrix()); shader.sendMat4("projectionMatrix", cam.getProjectionMatrix()); testScene.render(shader); shader.unbind(); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); return 0; }
Shader::Shader(const char *vertexFilename, const char *fragmentFilename, const char *geometryFilename, const char *tesselationCTRLFilename, const char *tesselationEVALFilename, const char *computeFilename, std::vector<std::string> &dynamicDefines) { bool errorTrigger = true; std::string source; if(computeFilename != NULL)//compute shader { computeShader = glCreateShader(GL_COMPUTE_SHADER); if(!loadShaderSource(computeFilename, source, dynamicDefines)) { glDeleteShader(computeShader); return; } const char *src = source.c_str(); glShaderSource( computeShader, 1, &src, NULL ); source.clear(); glCompileShader(computeShader); if(!checkShaderStatus(computeShader, computeFilename)) { glDeleteShader(computeShader); return; } program = glCreateProgram(); glAttachShader(program, computeShader); glDeleteShader(computeShader); } else//no compute shader { if(vertexFilename!=NULL) { vertexShader = glCreateShader(GL_VERTEX_SHADER); if(!loadShaderSource(vertexFilename, source, dynamicDefines)) { errorTrigger = false; } const char *src = source.c_str(); glShaderSource(vertexShader, 1, &src, NULL); source.clear(); } if(fragmentFilename != NULL) { fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if(!loadShaderSource(fragmentFilename, source, dynamicDefines)) { errorTrigger = false; } const char *src = source.c_str(); glShaderSource(fragmentShader, 1, &src, NULL); source.clear(); } if(geometryFilename != NULL) { geometryShader = glCreateShader(GL_GEOMETRY_SHADER); if(!loadShaderSource(geometryFilename, source, dynamicDefines)) { errorTrigger = false; } const char *src = source.c_str(); glShaderSource(geometryShader, 1, &src, NULL); source.clear(); } if(tesselationEVALFilename != NULL) { tesselationControlShader = glCreateShader(GL_TESS_CONTROL_SHADER); tesselationEvaluationShader = glCreateShader(GL_TESS_EVALUATION_SHADER); if(!loadShaderSource(tesselationCTRLFilename, source, dynamicDefines)) { errorTrigger = false; } const char *src = source.c_str(); glShaderSource(tesselationControlShader, 1, &src, NULL); source.clear(); if(!loadShaderSource(tesselationEVALFilename, source, dynamicDefines)) errorTrigger=false; src=source.c_str(); glShaderSource(tesselationEvaluationShader, 1, &src, NULL); source.clear(); } if(!errorTrigger) { glDeleteShader(vertexShader); glDeleteShader(fragmentShader); glDeleteShader(geometryShader); glDeleteShader(tesselationControlShader); glDeleteShader(tesselationEvaluationShader); return; } glCompileShader(vertexShader); if(fragmentFilename != NULL) { glCompileShader(fragmentShader); } if(geometryFilename != NULL) { glCompileShader(geometryShader); } if(tesselationEVALFilename != NULL) { glCompileShader(tesselationControlShader); glCompileShader(tesselationEvaluationShader); } if(!checkShaderStatus(vertexShader, vertexFilename)) { errorTrigger = false; } if(fragmentFilename != NULL && !checkShaderStatus(fragmentShader,fragmentFilename)) { errorTrigger = false; } if(geometryFilename != NULL && !checkShaderStatus(geometryShader,geometryFilename)) { errorTrigger = false; } if(tesselationEVALFilename != NULL && !checkShaderStatus(tesselationEvaluationShader, tesselationEVALFilename) && !checkShaderStatus(tesselationControlShader, tesselationCTRLFilename)) { errorTrigger = false; } if(!errorTrigger) { glDeleteShader(vertexShader); glDeleteShader(fragmentShader); glDeleteShader(geometryShader); glDeleteShader(tesselationEvaluationShader); glDeleteShader(tesselationControlShader); return; } program = glCreateProgram(); glAttachShader(program,vertexShader); if(fragmentFilename!=NULL) { glAttachShader(program,fragmentShader); } if(geometryFilename!=NULL) { glAttachShader(program,geometryShader); } if(tesselationEVALFilename!=NULL) { glAttachShader(program, tesselationControlShader); glAttachShader(program, tesselationEvaluationShader); } glDeleteShader(vertexShader); if(fragmentFilename != NULL) { glDeleteShader(fragmentShader); } if(geometryFilename != NULL) { glDeleteShader(geometryShader); } if(tesselationEVALFilename != NULL) { glDeleteShader(tesselationControlShader); glDeleteShader(tesselationEvaluationShader); } } //equal for normal and compute shader glLinkProgram(program); GLint testVal; glGetProgramiv(program, GL_LINK_STATUS,&testVal); if(testVal == GL_FALSE) { char errorLog[1024]; glGetProgramInfoLog(program, 1024, NULL, errorLog); if(vertexFilename != NULL) { QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << vertexFilename << " because of:\n "<< errorLog; } else { QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << computeFilename << " because of:\n "<< errorLog; } glDeleteProgram(program); } }
int main(int argc, char** argv) { osg::ArgumentParser arguments( &argc, argv ); std::string dbPath; arguments.read("--db_path", dbPath); std::srand ( unsigned ( std::time(0) ) ); auto board = Board(boardDefinition, boardSizeX, boardSizeY, dbPath); auto ghostFactory = GhostFactory(); auto main_obj = make_ref<osg::Group>(); main_obj->addChild(board.draw().get()); auto ghostModel = osgDB::readNodeFile(dbPath + "/cow.osg"); auto ghostCount = 16; while(ghostCount--) { main_obj->addChild(ghostFactory.drawGhost(board, ghostModel).get()); } // init rotate auto init_rotate = make_ref<osg::MatrixTransform>(); init_rotate->setMatrix( osg::Matrix::rotate(osg::PI * 2, osg::Vec3(1.0f, 0.0f, 0.0f)) ); // chain rotates init_rotate->addChild(main_obj); // Root group auto root = make_ref<osg::Group>(); root->addChild(init_rotate); // Setup fog if(FogEnabled) { osg::ref_ptr<osg::Fog> fog = new osg::Fog; fog->setMode( osg::Fog::EXP2 ); fog->setStart( 0.0f ); fog->setEnd(board.getFieldSizeX() * 20); fog->setDensity(0.0135); fog->setColor( osg::Vec4(0., 0., 0., 1.0) ); root->getOrCreateStateSet()->setAttributeAndModes(fog.get()); } // Start viewer osgViewer::Viewer viewer; // Set up flashlight auto lightSource = make_ref<osg::LightSource>(); lightSource->setReferenceFrame(osg::LightSource::ABSOLUTE_RF); auto light = lightSource->getLight(); const osg::Vec3 lightPosition{1.5, -1, -1}; // right, down, front light->setPosition(osg::Vec4{lightPosition, 1}); light->setDirection(osg::Vec3{0, 0, -1} * 30 - lightPosition); light->setSpotExponent(60); light->setSpotCutoff(90); light->setDiffuse(osg::Vec4(1, 1, 1, 1)); light->setAmbient(osg::Vec4(0.6, 0.6, 0.6, 1)); light->setSpecular(osg::Vec4(1, 1, 1, 1)); light->setLinearAttenuation(0.001); light->setConstantAttenuation(0.5); root->addChild(lightSource); double height = std::min(board.getFieldSizeX(), board.getFieldSizeY()) / 1.5; auto fpsManipulator = make_ref<FPSManipulator>(board, viewer, *light); fpsManipulator->setHomePosition( osg::Vec3d(board.getFieldCenterX(1), board.getFieldCenterY(10), height), osg::Vec3d(0.0f, 0.0f, height), osg::Vec3d(0.0f, 0.0f, 1.0f) ); auto keySwitch = make_ref<osgGA::KeySwitchMatrixManipulator>(); keySwitch->addNumberedMatrixManipulator(make_ref<osgGA::OrbitManipulator>()); keySwitch->addNumberedMatrixManipulator(fpsManipulator); viewer.setCameraManipulator(keySwitch); viewer.home(); viewer.setSceneData( root ); osgViewer::Viewer::Windows windows; viewer.getWindows(windows); viewer.getCamera()->setClearColor(osg::Vec4{0, 0, 0, 0}); viewer.getCamera()->getView()->setLightingMode(osg::View::HEADLIGHT); auto defaultLight = viewer.getCamera()->getView()->getLight(); defaultLight->setDiffuse(osg::Vec4(0, 0, 0, 1)); defaultLight->setAmbient(osg::Vec4(0, 0, 0, 1)); defaultLight->setSpecular(osg::Vec4(0, 0, 0, 1)); // Shaders auto program = make_ref<osg::Program>(); auto fragmentObject = make_ref<osg::Shader>(osg::Shader::FRAGMENT); loadShaderSource(fragmentObject, dbPath + "/shader.frag"); auto vertexObject = make_ref<osg::Shader>(osg::Shader::VERTEX); loadShaderSource(vertexObject, dbPath + "/shader.vert"); program->addShader(vertexObject); program->addShader(fragmentObject); root->getOrCreateStateSet()->setAttributeAndModes(program, osg::StateAttribute::ON); root->getOrCreateStateSet()->addUniform(new osg::Uniform("samplerName", TEXTURE_UNIT)); root->getOrCreateStateSet()->addUniform(new osg::Uniform("Shininess", BoardObjectsShininess)); root->getOrCreateStateSet()->addUniform(new osg::Uniform("FogEnabled", FogEnabled)); // Optimize osgUtil::Optimizer optimzer; optimzer.optimize(root); viewer.setUpViewOnSingleScreen(0); return viewer.run(); }
void ShaderEditOverlay::handleKeyDown(SDL_KeyboardEvent& event) { if (event.keysym.sym=='s' && isModEnabled(KMOD_CTRL, event.keysym.mod)) { saveShaderSource(); } if ('1'<=event.keysym.sym && event.keysym.sym<='3' && isModEnabled(KMOD_ALT, event.keysym.mod)) { mActiveEditor->Command(SCI_SETFOCUS, false); switch(event.keysym.sym) { case '1': mActiveEditor=&mSelectionList; break; case '2': mActiveEditor=&mShaderEditor; break; case '3': mActiveEditor=&mDebugOutputView; break; } mActiveEditor->Command(SCI_SETFOCUS, true); } if (event.keysym.sym==SDLK_F7 && isModEnabled(0, event.keysym.mod)&&mSelectedShader&&mSelectedProgram) { compileProgram(); mRequireReset = true; } else if (mActiveEditor==&mSelectionList) { switch (event.keysym.sym) { case SDLK_UP: mSelectionList.Command(SCI_LINEUP); break; case SDLK_DOWN: mSelectionList.Command(SCI_LINEDOWN); break; case SDLK_RETURN: if (mSelectionMode==SELMODE_PROGRAM_LIST) { fillListWithShaders(); mSelectionMode=SELMODE_SHADER_LIST; } else { loadShaderSource(); } break; case SDLK_BACKSPACE: if (mSelectionMode==SELMODE_SHADER_LIST) { fillListWithPrograms(); mSelectionMode=SELMODE_PROGRAM_LIST; } break; } } else { int sciKey; switch(event.keysym.sym) { case SDLK_DOWN: sciKey = SCK_DOWN; break; case SDLK_UP: sciKey = SCK_UP; break; case SDLK_LEFT: sciKey = SCK_LEFT; break; case SDLK_RIGHT: sciKey = SCK_RIGHT; break; case SDLK_HOME: sciKey = SCK_HOME; break; case SDLK_END: sciKey = SCK_END; break; case SDLK_PAGEUP: sciKey = SCK_PRIOR; break; case SDLK_PAGEDOWN: sciKey = SCK_NEXT; break; case SDLK_DELETE: sciKey = SCK_DELETE; break; case SDLK_INSERT: sciKey = SCK_INSERT; break; case SDLK_ESCAPE: sciKey = SCK_ESCAPE; break; case SDLK_BACKSPACE: sciKey = SCK_BACK; break; case SDLK_TAB: sciKey = SCK_TAB; break; case SDLK_RETURN: sciKey = SCK_RETURN; break; case SDLK_KP_PLUS: sciKey = SCK_ADD; break; case SDLK_KP_MINUS: sciKey = SCK_SUBTRACT; break; case SDLK_KP_DIVIDE: sciKey = SCK_DIVIDE; break; case SDLK_LGUI: sciKey = SCK_WIN; break; case SDLK_RGUI: sciKey = SCK_RWIN; break; case SDLK_MENU: sciKey = SCK_MENU; break; case SDLK_SLASH: sciKey = '/'; break; case SDLK_ASTERISK: sciKey = '`'; break; case SDLK_LEFTBRACKET: sciKey = '['; break; case SDLK_BACKSLASH: sciKey = '\\'; break; case SDLK_RIGHTBRACKET: sciKey = ']'; break; case SDLK_LSHIFT: case SDLK_RSHIFT: case SDLK_LALT: case SDLK_RALT: case SDLK_LCTRL: case SDLK_RCTRL: sciKey = 0; break; default: sciKey = event.keysym.sym; } if (sciKey) { bool consumed; bool ctrlPressed = event.keysym.mod&KMOD_LCTRL || event.keysym.mod&KMOD_RCTRL; bool altPressed = event.keysym.mod&KMOD_LALT || event.keysym.mod&KMOD_RALT; bool shiftPressed = event.keysym.mod&KMOD_LSHIFT || event.keysym.mod&KMOD_RSHIFT; mActiveEditor->KeyDown((SDLK_a<=sciKey && sciKey<=SDLK_z)?sciKey-'a'+'A':sciKey, shiftPressed, ctrlPressed, altPressed, &consumed ); } } }
void initialize() { ChangeCurrentOpenGLContext ctx(opengl_context_ptr); OpenGLBindings *b = new OpenGLBindings(); if (flextInit(opengl_context_ptr, b) == 0) { LOG_ERROR << "Failed to initialize flextGL."; exit(-1); } gl(b); input_data.allocate(352, 424 * 10); for(int i = 0; i < 3; ++i) stage1_data[i].allocate(512, 424); if(do_debug) stage1_debug.allocate(512, 424); stage1_infrared.allocate(512, 424); for(int i = 0; i < 2; ++i) filter1_data[i].allocate(512, 424); filter1_max_edge_test.allocate(512, 424); if(do_debug) filter1_debug.allocate(512, 424); if(do_debug) stage2_debug.allocate(512, 424); stage2_depth.allocate(512, 424); stage2_depth_and_ir_sum.allocate(512, 424); if(do_debug) filter2_debug.allocate(512, 424); filter2_depth.allocate(512, 424); stage1.setVertexShader(loadShaderSource(shader_folder + "default.vs")); stage1.setFragmentShader(loadShaderSource(shader_folder + "stage1.fs")); stage1.build(); filter1.setVertexShader(loadShaderSource(shader_folder + "default.vs")); filter1.setFragmentShader(loadShaderSource(shader_folder + "filter1.fs")); filter1.build(); stage2.setVertexShader(loadShaderSource(shader_folder + "default.vs")); stage2.setFragmentShader(loadShaderSource(shader_folder + "stage2.fs")); stage2.build(); filter2.setVertexShader(loadShaderSource(shader_folder + "default.vs")); filter2.setFragmentShader(loadShaderSource(shader_folder + "filter2.fs")); filter2.build(); if(do_debug) { debug.setVertexShader(loadShaderSource(shader_folder + "default.vs")); debug.setFragmentShader(loadShaderSource(shader_folder + "debug.fs")); debug.build(); } GLenum debug_attachment = do_debug ? GL_COLOR_ATTACHMENT0 : GL_NONE; gl()->glGenFramebuffers(1, &stage1_framebuffer); gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage1_framebuffer); const GLenum stage1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4 }; gl()->glDrawBuffers(5, stage1_buffers); if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage1_debug.texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage1_data[0].texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage1_data[1].texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, stage1_data[2].texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT4, GL_TEXTURE_RECTANGLE, stage1_infrared.texture, 0); gl()->glGenFramebuffers(1, &filter1_framebuffer); gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter1_framebuffer); const GLenum filter1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 }; gl()->glDrawBuffers(4, filter1_buffers); if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter1_debug.texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter1_data[0].texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, filter1_data[1].texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, filter1_max_edge_test.texture, 0); gl()->glGenFramebuffers(1, &stage2_framebuffer); gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage2_framebuffer); const GLenum stage2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 }; gl()->glDrawBuffers(3, stage2_buffers); if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage2_debug.texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage2_depth.texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage2_depth_and_ir_sum.texture, 0); gl()->glGenFramebuffers(1, &filter2_framebuffer); gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter2_framebuffer); const GLenum filter2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1 }; gl()->glDrawBuffers(2, filter2_buffers); if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter2_debug.texture, 0); gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter2_depth.texture, 0); Vertex bl = {-1.0f, -1.0f, 0.0f, 0.0f }, br = { 1.0f, -1.0f, 512.0f, 0.0f }, tl = {-1.0f, 1.0f, 0.0f, 424.0f }, tr = { 1.0f, 1.0f, 512.0f, 424.0f }; Vertex vertices[] = { bl, tl, tr, tr, br, bl }; gl()->glGenBuffers(1, &square_vbo); gl()->glGenVertexArrays(1, &square_vao); gl()->glBindVertexArray(square_vao); gl()->glBindBuffer(GL_ARRAY_BUFFER, square_vbo); gl()->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLint position_attr = stage1.getAttributeLocation("Position"); gl()->glVertexAttribPointer(position_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0); gl()->glEnableVertexAttribArray(position_attr); GLint texcoord_attr = stage1.getAttributeLocation("TexCoord"); gl()->glVertexAttribPointer(texcoord_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(2 * sizeof(float))); gl()->glEnableVertexAttribArray(texcoord_attr); }
int main() { glfwInit(); ////our window //GLFWwindow* window; //window = glfwCreateWindow(800, 600, "ParticleSystemXML", NULL, NULL); //glfwMakeContextCurrent(window); // ////CAM //cam.setKeySpeed(4.0); //iH.setAllInputMaps(cam); //glfwSetKeyCallback(window, key_callback); //cam.setFOV(50); //cam.setNearFar(1, 100); Window testWindow(500, 50, 800, 600, "ParticleSystem"); glfwMakeContextCurrent(testWindow.getWindow()); // Callback glfwSetKeyCallback(testWindow.getWindow(), key_callback); cam.setKeySpeed(4.0); cam.setNearFar(0.1, 100); cam.setPosition(glm::vec4(0, 0, 8, 0)); glewInit(); //our renderer OpenGL3Context context; Renderer *renderer; renderer = new Renderer(context); //////////////////////Textures////////////////////// Texture* fireTex = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/Fire2_M.png"); Texture* fireTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire1_M.png"); Texture* fireTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire3_M.png"); Texture* fireTex3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/flame02_L.png"); //Texture* fireFlickering1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_1.png"); //Texture* fireFlickering2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_2.png"); //Texture* fireFlickering3 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_3.png"); //Texture* fireFlickering4 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fire_flickering_4.png"); Texture* fireSparkleTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle1_S.png"); Texture* fireSparkleTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/fire/fireSparkle2.png"); Texture* texFireworkBlue = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_blue.png"); Texture* texFireworkRed = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_red.png"); Texture* texFireworkGreen = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_green.png"); Texture* texFireworkGold = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_gold.png"); Texture* texFireworkTail = new Texture((char*)RESOURCES_PATH "/ParticleSystem/firework/firework_tail.png"); Texture* smokeWhiteTex1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite01.png"); Texture* smokeWhiteTex2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeWhite/smokeWhite02.png"); Texture* smokeBlack1 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack01.png"); Texture* smokeBlack2 = new Texture((char*)RESOURCES_PATH "/ParticleSystem/smoke/smokeBlack/smokeBlack02.png"); //////////////////////Emitter////////////////////// //Emitter explosion sparkle Emitter* explosionSparkle = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.25, 0.01, 80, 1.25, true); explosionSparkle->setVelocity(5); //explosionSparkle->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.3), 3.0f); explosionSparkle->usePhysicPointGravity(glm::vec3(0.0, 0.0, 0.0), 0.6, 10.0, 2, 4.0f, true); explosionSparkle->addTexture(fireSparkleTex1, 1.0); explosionSparkle->defineLook(true, 0.01, 0.0, 0.1); //Emitter explosion fire //TODO //Emitter fire smoke Emitter* fire = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.2, 2, 5.0, true); fire->setVelocity(5); fire->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 5.0), 0.5f); fire->addTexture(fireTex1, 1.0); fire->addTexture(fireTex2, 0.7); fire->addTexture(smokeBlack2, 0.1); //fire->addTexture(smokeBlack2, 0.1); //fire->addTexture(smokeWhiteTex2, 0.25); std::vector<float> sizeF{ 0.05f, 0.5f, 0.75f, 1.0f }; std::vector<float> timeF{ 0.0f, 0.4f, 0.75f, 1.0f }; fire->defineLook(true, sizeF, timeF, 0.5, 4.0, 3.0, true, 0.3); fire->switchToGeometryShader(); //Emitter fire flickering Emitter* fireFlickering = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.2, 1, 2.0, true); fireFlickering->setVelocity(5); fireFlickering->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.5), 0.3f); /*fireFlickering->addTexture(fireFlickering1, 1.0); fireFlickering->addTexture(fireFlickering2, 0.7); fireFlickering->addTexture(fireFlickering3, 0.5); fireFlickering->addTexture(fireFlickering4, 0.3);*/ fireFlickering->defineLook(true, 0.1, 0.5, 1.0, 0.5, true, 0.3); fireFlickering->switchToGeometryShader(); Emitter* fireSparkle = new Emitter(0, glm::vec3(0.0, 0.1, 0.0), 0.0, 0.05, 3, 2.5, true); fireSparkle->setVelocity(5); fireSparkle->usePhysicDirectionGravity(glm::vec4(0.0, 1.0, 0.0, 0.8), 0.5f); fireSparkle->addTexture(fireSparkleTex1, 1.0); fireSparkle->defineLook(true, 0.05, 0.5, 0.5); //Emitter firework explosion Emitter* fireworkExplosion = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.1, 0.01, 80, 2.0, true); fireworkExplosion->setVelocity(6); //fireworkExplosion->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 0.6), 3.0f); fireworkExplosion->usePhysicPointGravity(glm::vec3(0.0, -2.0, 0.0), 0.9, 5.0, 2, 2.0f, true); fireworkExplosion->addTexture(texFireworkRed, 1.0); fireworkExplosion->defineLook(true, 0.04, 0.0, 0.5); fireworkExplosion->setStartTime(2.0); //Emitter firework tail Emitter* fireworkTail = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 2.0, 0.01, 20, 0.5, true); fireworkTail->setVelocity(5); //fireworkTail->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, 2.9), 0.2f); fireworkTail->usePhysicPointGravity(glm::vec3(0.0, -4.0, 0.0), 30.6, 10.0, 2, 0.2f, true); fireworkTail->addTexture(texFireworkTail, 1.0); fireworkTail->defineLook(true, 0.001, 0.0, 0.1); //FINAL EMITTER WHITE SMOKE Emitter* smokeWhite = new Emitter(0, glm::vec3(0.0, 0.0, 0.0), 0.0, 0.4, 1, 8.0, true); smokeWhite->setVelocity(2); smokeWhite->usePhysicDirectionGravity(glm::vec4(0.0, -1.0, 0.0, -0.8), 0.3f); smokeWhite->addTexture(smokeWhiteTex1, 1.0); smokeWhite->addTexture(smokeWhiteTex2, 0.25); std::vector<float> smokeWhiteSize{ 0.05f, 0.5f, 0.75f, 1.0f }; std::vector<float> smokeWhiteTime{ 0.0f, 0.4f, 0.75f, 1.0f }; smokeWhite->defineLook(true, smokeWhiteSize, smokeWhiteTime, 1.0, 2.0, 1.0, false, 0.3); smokeWhite->switchToGeometryShader(); //////////////////////Effect////////////////////// Effect* efExplosion = new Effect(); efExplosion->addEmitter(explosionSparkle); Effect* efFire = new Effect(); efFire->addEmitter(fire); //efFire->addEmitter(fireFlickering); efFire->addEmitter(fireSparkle); efFire->saveEffect(RESOURCES_PATH "/XML/Effect_Fire.xml"); Effect* efFirework = new Effect(); efFirework->addEmitter(fireworkTail); efFirework->addEmitter(fireworkExplosion); //efFirework->saveEffect(RESOURCES_PATH "/XML/Effect_Firework.xml"); Effect* efFireworkTail = new Effect(); efFireworkTail->addEmitter(fireworkTail); Effect* efFireworkExplosion = new Effect(); efFireworkExplosion->addEmitter(fireworkExplosion); Effect* efSmWhi = new Effect(); efSmWhi->addEmitter(smokeWhite); efSmWhi->saveEffect(RESOURCES_PATH "/XML/Effect_SmokeWhite.xml"); //////////////////////ParticleSystem////////////////////// //ParticleSystem* psExplosion = new ParticleSystem(glm::vec3(0, -1, 0), efExplosion); //ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), efFire); ParticleSystem* psFire = new ParticleSystem(glm::vec3(-2, 0, 3), RESOURCES_PATH "/XML/Effect_Fire.xml"); ParticleSystem* psFirework = new ParticleSystem(glm::vec3(0, 0, 5), efFirework); ParticleSystem* psFireworkTail = new ParticleSystem(glm::vec3(0, 0, 5), efFireworkTail); ParticleSystem* psFireworkExplosion = new ParticleSystem(glm::vec3(0, 2, 5), efFireworkExplosion); ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), efSmWhi); //ParticleSystem* psSmokeWhite = new ParticleSystem(glm::vec3(2, 0, 3), RESOURCES_PATH "/XML/Effect_SmokeWhite.xml"); ParticleSystem* psFireworkRed = new ParticleSystem(glm::vec3(-6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkRed.xml"); ParticleSystem* psFireworkBlue = new ParticleSystem(glm::vec3(-2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkBlue.xml"); ParticleSystem* psFireworkGreen = new ParticleSystem(glm::vec3(2, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGreen.xml"); ParticleSystem* psFireworkGold = new ParticleSystem(glm::vec3(6, -1, -3), RESOURCES_PATH "/XML/Effect_FireworkGold.xml"); ParticleSystem* psComicCloud = new ParticleSystem(glm::vec3(0, -1, 3), RESOURCES_PATH "/XML/Effect_ComicCloud.xml"); //////////////////////Node////////////////////// //Node nodeExplosion("nodeExplosion"); //nodeExplosion.setCamera(&cam); //nodeExplosion.addParticleSystem(psExplosion); //nodeExplosion.setParticleActive(true); // //Node fireNode("fireNode"); //fireNode.setCamera(&cam); //fireNode.addParticleSystem(psFire); //fireNode.setParticleActive(true); // //Node nodeFirework("fireworkNode"); //nodeFirework.setCamera(&cam); //nodeFirework.addParticleSystem(psFirework); //nodeFirework.setParticleActive(true); // //Node whiteSmokeNode("whiteSmokeNode"); //whiteSmokeNode.setCamera(&cam); //whiteSmokeNode.addParticleSystem(psSmokeWhite); //whiteSmokeNode.setParticleActive(true); ////Firework //Node nodeFireworkRed("fireworkRedNode"); //nodeFireworkRed.setCamera(&cam); //nodeFireworkRed.addParticleSystem(psFireworkRed); //nodeFireworkRed.setParticleActive(true); //Node nodeFireworkBlue("fireworBlueNode"); //nodeFireworkBlue.setCamera(&cam); //nodeFireworkBlue.addParticleSystem(psFireworkBlue); //nodeFireworkBlue.setParticleActive(true); //Node nodeFireworkGreen("fireworkGreenNode"); //nodeFireworkGreen.setCamera(&cam); //nodeFireworkGreen.addParticleSystem(psFireworkGreen); //nodeFireworkGreen.setParticleActive(true); //Node nodeFireworkGold("fireworkGoldNode"); //nodeFireworkGold.setCamera(&cam); //nodeFireworkGold.addParticleSystem(psFireworkGold); //nodeFireworkGold.setParticleActive(true); // Shader VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.vert"))); FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ColorShader3D/ColorShader3D.frag"))); ShaderProgram shader(vs, fs); //need scene here mainly because of input Level testLevel("testLevel"); Scene testScene("testScene"); testLevel.addScene(&testScene); testLevel.changeScene("testScene"); //Add Camera to Scene testScene.getScenegraph()->addCamera(&cam); testScene.getScenegraph()->setActiveCamera("Pilotview"); //Set Input-Maps and activate one iH.setAllInputMaps(*(testScene.getScenegraph()->getActiveCamera())); iH.changeActiveInputMap(MapType::CAMPILOTVIEW); iH.getActiveInputMap()->update(cam); //Object Cube cube; Texture bricks((char*)RESOURCES_PATH "/Wall/bricks_diffuse.png"); Node cube1("cube"); cube1.addGeometry(&cube); cube1.addTexture(&bricks); cube1.setModelMatrix(glm::translate(cube1.getModelMatrix(), glm::vec3(0.0, 0.0, 0.0))); //cube1.setModelMatrix(glm::scale(cube1.getModelMatrix(), glm::vec3(0.5, 0.5, 0.5))); testScene.getScenegraph()->getRootNode()->addChildrenNode(&cube1); //add nodes to the scenegraph //testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeExplosion); //testScene.getScenegraph()->getRootNode()->addChildrenNode(&fireNode); //testScene.getScenegraph()->getRootNode()->addChildrenNode(&whiteSmokeNode); //testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFirework); /*testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkRed); testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkBlue); testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGreen); testScene.getScenegraph()->getRootNode()->addChildrenNode(&nodeFireworkGold);*/ //using this, the ParticleSystems get rendered in order of their distance to the camera testScene.getScenegraph()->addParticleSystem(psFire); testScene.getScenegraph()->addParticleSystem(psSmokeWhite); testScene.getScenegraph()->addParticleSystem(psFireworkBlue); testScene.getScenegraph()->addParticleSystem(psFireworkRed); testScene.getScenegraph()->addParticleSystem(psFireworkGreen); testScene.getScenegraph()->addParticleSystem(psFireworkGold); //testScene.getScenegraph()->addParticleSystem(psComicCloud); ////TEST //Emitter* etest = new Emitter(0, glm::vec3(0, 0, 0), 0, 1, 1000000, 1, true); //etest->setVelocity(6); //etest->usePhysicPointGravity(glm::vec3(0, 0, 0), 0.5, 20, 1, -2.5, true); //etest->defineLook(false, 0.005); //Effect* eftest = new Effect(); //eftest->addEmitter(etest); //ParticleSystem* pstest = new ParticleSystem(glm::vec3(0, 2, 0), eftest); //testScene.getScenegraph()->addParticleSystem(pstest); //pstest->start(); //start the ParticleSystems psFire->start(); psSmokeWhite->start(); //psExplosion->start(); //psFirework->start(); psFireworkRed->start(); psFireworkBlue->start(); psFireworkGreen->start(); psFireworkGold->start(); //psComicCloud->start(); double startTime = glfwGetTime(); double lastTime = glfwGetTime(); int nbFrames = 0; while (!glfwWindowShouldClose(testWindow.getWindow())) { // Measure speed double currentTime = glfwGetTime(); nbFrames++; if (currentTime - lastTime >= 1.0) { // If last prinf() was more than 1 sec ago // printf and reset timer //printf("%f ms/frame\n", 1000.0 / double(nbFrames)); nbFrames = 0; lastTime += 1.0; } double dt = glfwGetTime() - startTime; cam.setSensitivity(dt); startTime = glfwGetTime(); /*glEnable(GL_DEPTH); glEnable(GL_DEPTH_TEST); glEnable(GL_BLEND); glClearColor(0.5, 0.5, 0.5, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shader.bind(); shader.sendMat4("viewMatrix", cam.getViewMatrix()); shader.sendMat4("projectionMatrix", cam.getProjectionMatrix()); testScene.render(shader); testScene.renderParticleSystems(); shader.unbind();*/ //renderer->useBloom(true); renderer->renderScene(testScene, testWindow); //update Positions of firework ParticleSystems glm::vec3 pos = psFireworkRed->getPosition(); psFireworkRed->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z)); pos = psFireworkBlue->getPosition(); psFireworkBlue->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z)); pos = psFireworkGreen->getPosition(); psFireworkGreen->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z)); pos = psFireworkGold->getPosition(); psFireworkGold->setPosition(glm::vec3(pos.x, pos.y + (2 * dt), pos.z)); /*glfwSwapBuffers(testWindow.getWindow()); glfwPollEvents();*/ } glfwDestroyWindow(testWindow.getWindow()); glfwTerminate(); return 0; }
void MaterialTemplate::attachShader(const std::string& fname, GLenum type) { gl::Shader shader(type); if (loadShaderSource(fname, shader)) { shaders.push_back(std::move(shader)); } }
int main() { glfwInit(); //our window GLFWwindow* window; window = glfwCreateWindow(800, 600, "ComputeShader", NULL, NULL); glfwMakeContextCurrent(window); cam.setName("PilotviewCam"); cam.setPosition(glm::vec4(0, 0, 2.0, 1.0)); cam.setNearFar(0.01f, 10.0f); // Set all InputMaps and set one InputMap active iH.setAllInputMaps(cam); iH.changeActiveInputMap("Pilotview"); // Callback glfwSetKeyCallback(window, key_callback); glewInit(); /*MAGIC*/ ComputeShader cs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/simpleComputeShader.comp"))); ShaderProgram compute(cs); VertexShader vs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.vert"))); FragmentShader fs(loadShaderSource(SHADERS_PATH + std::string("/ComputeShader/ExComputeShader.frag"))); ShaderProgram render(vs, fs); //GLuint render_vao; //glGenVertexArrays(1, &render_vao); //glBindVertexArray(render_vao); GLuint position_ssbo; glGenBuffers(1, &position_ssbo); glBindBuffer(GL_SHADER_STORAGE_BUFFER, position_ssbo); glBufferData(GL_SHADER_STORAGE_BUFFER, PARTICLE_COUNT * sizeof(struct pos), NULL, GL_STATIC_DRAW); GLint bufMask = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT; struct pos* positions = (struct pos*)glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, PARTICLE_COUNT * sizeof(struct pos), bufMask); for (int i = 0; i < PARTICLE_COUNT; i++) { positions[i].x = ((rand() % 100) / 100.0f) - 0.5; positions[i].y = ((rand() % 100) / 100.0f) - 0.5; positions[i].z = ((rand() % 100) / 100.0f) - 0.5; positions[i].w = 1; } glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); //glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL); //glEnableVertexAttribArray(0); //std::cout << "HIER MUSS 000 STEHEN: " << positions[1].x << positions[1].y << positions[1].z << std::endl; /*END*/ float startCamTime = glfwGetTime(); double lastTime = glfwGetTime(); int nbFrames = 0; while (!glfwWindowShouldClose(window)) { // Measure speed double currentTime = glfwGetTime(); nbFrames++; if (currentTime - lastTime >= 1.0){ // If last prinf() was more than 1 sec ago // printf and reset timer printf("%f ms/frame\n", 1000.0 / double(nbFrames)); nbFrames = 0; lastTime += 1.0; } cam.setSensitivity(glfwGetTime() - startCamTime); startCamTime = cam.getSensitivity(); compute.bind(); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, position_ssbo); compute.sendFloat("time", glfwGetTime()); glDispatchCompute(PARTICLE_GROUP_COUNT, 1, 1); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0); glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT); compute.unbind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable(GL_DEPTH_TEST); render.bind(); glBindBuffer(GL_ARRAY_BUFFER, position_ssbo); render.sendMat4("viewMatrix", cam.getViewMatrix()); render.sendMat4("projectionMatrix", cam.getProjectionMatrix()); glVertexPointer(4, GL_FLOAT, 0, (void*)0); glEnableClientState(GL_VERTEX_ARRAY); //glPointSize(1.0); glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT); glDisableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, 0); render.unbind(); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); return 0; }
void Renderer::init(int windowWidth, int windowHeight) { m_windowWidth = windowWidth; m_windowHeight = windowHeight; //create ping pong fbos m_ping = new FBO(windowWidth, windowHeight, 3, true, false); m_pong = new FBO(windowWidth, windowHeight, 3, true, false); m_gBuffer = new FBO(windowWidth, windowHeight, 3, true, false); m_smFBO = new FBO(windowWidth, windowHeight, 1, true, false); //load Shader if (!m_shaderGBuffer) { VertexShader vsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.vert"))); FragmentShader fsGBuffer(loadShaderSource(SHADERS_PATH + std::string("/GBuffer/GBuffer.frag"))); m_shaderGBuffer = new ShaderProgram(vsGBuffer, fsGBuffer); } if (m_useDeferredShading && !m_shaderDSLighting && !m_shaderDSCompositing) { VertexShader vsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.vert"))); FragmentShader fsDsLighting(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsLighting.frag"))); m_shaderDSLighting = new ShaderProgram(vsDsLighting, fsDsLighting); VertexShader vsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.vert"))); FragmentShader fsDsCompositing(loadShaderSource(SHADERS_PATH + std::string("/DeferredShading/dsFinalCompositing.frag"))); m_shaderDSCompositing = new ShaderProgram(vsDsCompositing, fsDsCompositing); } if (m_useReflections && !m_shaderRLR) { VertexShader vsRLR(loadShaderSource(SHADERS_PATH + std::string("/RealtimeLocalReflections/RealtimeLocalReflections.vert"))); FragmentShader fsRLR(loadShaderSource(SHADERS_PATH + std::string("/RealtimeLocalReflections/RealtimeLocalReflections.frag"))); m_shaderRLR = new ShaderProgram(vsRLR, fsRLR); } if (!m_shaderSFQ) { VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.frag"))); m_shaderSFQ = new ShaderProgram(vsSfq, fsSfq); } if (m_useBloom && !m_shaderBloom) { VertexShader vsBloom(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsBloom(loadShaderSource(SHADERS_PATH + std::string("/Bloom/Bloom.frag"))); m_shaderBloom = new ShaderProgram(vsBloom, fsBloom); } if (m_useBlur && !m_shaderBlur) { VertexShader vsBlur(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsBlur(loadShaderSource(SHADERS_PATH + std::string("/Blur/blur1D.frag"))); m_shaderBlur = new ShaderProgram(vsBlur, fsBlur); } if (m_useRadialBlur && !m_shaderRadialBlur) { VertexShader vsBlur(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsBlur(loadShaderSource(SHADERS_PATH + std::string("/RadialBlur/RadialBlur.frag"))); m_shaderRadialBlur = new ShaderProgram(vsBlur, fsBlur); } if (m_useDoF && !m_shaderDoF) { VertexShader vsDoF(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsDoF(loadShaderSource(SHADERS_PATH + std::string("/DoF/DoF.frag"))); m_shaderDoF = new ShaderProgram(vsDoF, fsDoF); VertexShader vsDepth(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.vert"))); FragmentShader fsDepth(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.frag"))); m_shaderDepth = new ShaderProgram(vsDepth, fsDepth); } if (m_useAntiAliasing && !m_shaderFXAA) { VertexShader vsFXAA(loadShaderSource(SHADERS_PATH + std::string("/FXAA/FXAA.vert"))); FragmentShader fsFXAA(loadShaderSource(SHADERS_PATH + std::string("/FXAA/FXAA.frag"))); m_shaderFXAA = new ShaderProgram(vsFXAA, fsFXAA); } if (m_useSSAO && !m_shaderSSAOcalc && !m_shaderSSAOblur && !m_shaderSSAOfinal) { VertexShader vsSSAO(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssao.vert"))); FragmentShader fsSSAO(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssao.frag"))); m_shaderSSAOcalc = new ShaderProgram(vsSSAO, fsSSAO); VertexShader vsSfq(loadShaderSource(SHADERS_PATH + std::string("/ScreenFillingQuad/ScreenFillingQuad.vert"))); FragmentShader fsBLUR(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssaoBlur.frag"))); m_shaderSSAOblur = new ShaderProgram(vsSfq, fsBLUR); FragmentShader fsFinal(loadShaderSource(SHADERS_PATH + std::string("/SSAO/ssaoFinal.frag"))); m_shaderSSAOfinal = new ShaderProgram(vsSfq, fsFinal); } if (m_useShadowMapping && !m_shaderShadowMapping) { VertexShader vsSM(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.vert"))); FragmentShader fsSM(loadShaderSource(SHADERS_PATH + std::string("/ShadowMapping/ShadowMap.frag"))); m_shaderShadowMapping = new ShaderProgram(vsSM, fsSM); if(!m_smCam) m_smCam = new Pilotview("smCam"); m_smCam->setNearFar(1.0f,30.0f); } }