int Window::getHeight() const { int height; glfwGetFramebufferSize(handle, nullptr, &height); return height; }
int main(int argc, const char * argv[]) { if(!glfwInit()){ return -1; } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); auto window = glfwCreateWindow(WIDTH, HEIGHT, "Lighting Maps", nullptr, nullptr); if (nullptr == window) { std::cout << "Failed to create GLFW windows" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); int actualWidth; int actualHeight; glfwGetFramebufferSize(window, &actualWidth, &actualHeight); glViewport(0, 0, actualWidth, actualHeight); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // GLFW Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glEnable(GL_DEPTH_TEST); Shader lightingShader("vertex.vsh", "fragment.fsh"); Shader lampShader("vertex.vsh", "lamp.fsh"); GLfloat vertices[] = { // Positions // Normals // Texture Coords -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }; int width, height; unsigned char* image = SOIL_load_image("container2.png", &width, &height, 0, SOIL_LOAD_RGB); GLuint diffuseMap; glGenTextures(1, &diffuseMap); glBindTexture(GL_TEXTURE_2D, diffuseMap); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); image = SOIL_load_image("lighting_maps_specular_color.png", &width, &height, 0, SOIL_LOAD_RGB); GLuint specularMap; glGenTextures(1, &specularMap); glBindTexture(GL_TEXTURE_2D, specularMap); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); image = SOIL_load_image("matrix.jpg", &width, &height, 0, SOIL_LOAD_RGB); GLuint emissionMap; glGenTextures(1, &emissionMap); glBindTexture(GL_TEXTURE_2D, emissionMap); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); GLuint VAO; glGenVertexArrays(1, &VAO); glBindVertexArray(VAO); GLuint VBO; glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); GLuint lightVAO; glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); // We only need to bind to the VBO, the container's VBO's data already contains the correct data. glBindBuffer(GL_ARRAY_BUFFER, VBO); // Set the vertex attributes (only position data for our lamp) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); while (!glfwWindowShouldClose(window)) { GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents(); do_movement(); // Clear the colorbuffer glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use cooresponding shader when setting uniforms/drawing objects lightingShader.Use(); GLint objectColorLoc = glGetUniformLocation(lightingShader.Program, "objectColor"); GLint lightColorLoc = glGetUniformLocation(lightingShader.Program, "lightColor"); GLint lightPosLoc = glGetUniformLocation(lightingShader.Program, "light.position"); GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos"); glUniform3f(objectColorLoc, 1.0f, 0.5f, 0.31f); glUniform3f(lightColorLoc, 1.0f, 1.0f, 1.0f); glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z); glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z); GLint matDiffuseLoc = glGetUniformLocation(lightingShader.Program, "material.diffuse"); glUniform1i(matDiffuseLoc, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, diffuseMap); GLint matSpecularLoc = glGetUniformLocation(lightingShader.Program, "material.specular"); glUniform1i(matSpecularLoc, 1); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, specularMap); GLint matEmissionLoc = glGetUniformLocation(lightingShader.Program, "material.emission"); glUniform1i(matEmissionLoc, 2); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, emissionMap); GLint matShineLoc = glGetUniformLocation(lightingShader.Program, "material.shininess"); glUniform1f(matShineLoc, 32.0f); // Create camera transformations glm::mat4 view; view = camera.GetViewMatrix(); glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f); // Get the uniform locations GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model"); GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view"); GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection"); // Pass the matrices to the shader glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); // Set lights properties glUniform3f(glGetUniformLocation(lightingShader.Program, "light.ambient"), 2.6f, 2.6f, 2.6f); glUniform3f(glGetUniformLocation(lightingShader.Program, "light.diffuse"), 0.5f, 0.5f, 0.5f); glUniform3f(glGetUniformLocation(lightingShader.Program, "light.specular"), 1.0f, 1.0f, 1.0f); // Draw the container (using container's vertex attributes) glBindVertexArray(VAO); glm::mat4 model; glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); // Also draw the lamp object, again binding the appropriate shader lampShader.Use(); // Get location objects for the matrices on the lamp shader (these could be different on a different shader) modelLoc = glGetUniformLocation(lampShader.Program, "model"); viewLoc = glGetUniformLocation(lampShader.Program, "view"); projLoc = glGetUniformLocation(lampShader.Program, "projection"); // Set matrices glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); model = glm::mat4(); model = glm::translate(model, lightPos); model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); // Draw the light object (using light's vertex attributes) glBindVertexArray(lightVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); } glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); glfwTerminate(); return 0; }
int main(int argc, char** argv) { int ch; GLFWwindow* windows[2]; GLuint texture, program, vertex_buffer; GLint mvp_location, vpos_location, color_location, texture_location; srand((unsigned int) time(NULL)); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); while ((ch = getopt(argc, argv, "d")) != -1) { switch (ch) { case 'd': glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); break; } } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); windows[0] = glfwCreateWindow(400, 400, "First", NULL, NULL); if (!windows[0]) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(windows[0], key_callback); glfwMakeContextCurrent(windows[0]); // Only enable vsync for the first of the windows to be swapped to // avoid waiting out the interval for each window glfwSwapInterval(1); // The contexts are created with the same APIs so the function // pointers should be re-usable between them gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); if (GLAD_GL_KHR_debug) { glDebugMessageCallback(debug_callback, NULL); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE); } // Create the OpenGL objects inside the first context, created above // All objects will be shared with the second context, created below { int x, y; char pixels[16 * 16]; GLuint vertex_shader, fragment_shader; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); for (y = 0; y < 16; y++) { for (x = 0; x < 16; x++) pixels[y * 16 + x] = rand() % 256; } glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 16, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); vertex_shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL); glCompileShader(vertex_shader); fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL); glCompileShader(fragment_shader); program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); mvp_location = glGetUniformLocation(program, "MVP"); color_location = glGetUniformLocation(program, "color"); texture_location = glGetUniformLocation(program, "texture"); vpos_location = glGetAttribLocation(program, "vPos"); glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); } glUseProgram(program); glUniform1i(texture_location, 0); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), (void*) 0); windows[1] = glfwCreateWindow(400, 400, "Second", NULL, windows[0]); if (!windows[1]) { glfwTerminate(); exit(EXIT_FAILURE); } // Place the second window to the right of the first { int xpos, ypos, left, right, width; glfwGetWindowSize(windows[0], &width, NULL); glfwGetWindowFrameSize(windows[0], &left, NULL, &right, NULL); glfwGetWindowPos(windows[0], &xpos, &ypos); glfwSetWindowPos(windows[1], xpos + width + left + right, ypos); } glfwSetKeyCallback(windows[1], key_callback); glfwMakeContextCurrent(windows[1]); // While objects are shared, the global context state is not and will // need to be set up for each context glUseProgram(program); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), (void*) 0); while (!glfwWindowShouldClose(windows[0]) && !glfwWindowShouldClose(windows[1])) { int i; const vec3 colors[2] = { { 0.3f, 0.4f, 1.f }, { 0.8f, 0.4f, 1.f } }; for (i = 0; i < 2; i++) { int width, height; mat4x4 mvp; glfwGetFramebufferSize(windows[i], &width, &height); glfwMakeContextCurrent(windows[i]); glViewport(0, 0, width, height); mat4x4_ortho(mvp, 0.f, 1.f, 0.f, 1.f, 0.f, 1.f); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp); glUniform3fv(color_location, 1, colors[i]); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glfwSwapBuffers(windows[i]); } glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
int main(int argc, char* argv[]) { glfwSetErrorCallback([](int error, const char* description) { std::cerr << "ERROR " << std::hex << error << std::dec << " ; " << description << std::endl; }); if (!glfwInit()) { std::cerr << "ERROR ; glfwInit() failed" << std::endl; exit(EXIT_FAILURE); } glfwWindowHint(GLFW_STEREO, true); GLFWwindow* window = glfwCreateWindow(640, 480, "Simple-Quad Buffered Program", nullptr, nullptr); if (!window) { std::cerr << "ERROR ; glfwCreateWindow(...) failed" << std::endl; glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); //glfwSwapInterval(1); glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods) { if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) glfwSetWindowShouldClose(window, GL_TRUE); }); while (!glfwWindowShouldClose(window)) { float ratio; int width, height; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float)height; glViewport(0, 0, width, height); const float spin = (float)glfwGetTime() * 50.f; bool left = true; do { // switch to the eye glDrawBuffer(left ? GL_BACK_LEFT : GL_BACK_RIGHT); glClear(GL_COLOR_BUFFER_BIT); // setup the view-projection matricies glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-ratio, ratio, -1.f, 1.f, 1.f, -1.f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotatef(left ? -spin : spin, 0.f, 0.f, 1.f); // draw the thing glBegin(GL_TRIANGLES); { glColor3f(1.f, 0.f, 0.f); glVertex3f(-0.6f, -0.4f, 0.f); glColor3f(0.f, 1.f, 0.f); glVertex3f(0.6f, -0.4f, 0.f); glColor3f(0.f, 0.f, 1.f); glVertex3f(0.f, 0.6f, 0.f); } glEnd(); // draw the side thingies glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glBegin(GL_QUADS); if (left) { // left side, eye, and is red glColor3f(1.f, 0.f, 0.f); glVertex3f(-0.9f, +1, 0.f); glVertex3f(-0.9f, -1, 0.f); glVertex3f(-0.8f, -1, 0.f); glVertex3f(-0.8f, +1, 0.f); } else { // right side, eye and is blue glColor3f(0.f, 0.f, 1.f); glVertex3f(+0.8f, -1, 0.f); glVertex3f(+0.8f, +1, 0.f); glVertex3f(+0.9f, +1, 0.f); glVertex3f(+0.9f, -1, 0.f); } glEnd(); // switch eyes left = !left; // if we get here and left is now true ; we've just finished the right eye and we can stop } while (false == left); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); return EXIT_SUCCESS; }
int main() { constexpr int SIZE = 4; RubiksCubeController<SIZE> rcc; glfwInit(); int count; GLFWmonitor ** monitors = glfwGetMonitors(&count); GLFWmonitor * monitor = monitors[0]; GLFWvidmode const * mode = glfwGetVideoMode(monitor); glfwWindowHint(GLFW_RED_BITS, mode->redBits); glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits); glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits); glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate); //GLFWwindow * window = glfwCreateWindow(mode->width, mode->height, "RubiksCube", monitor, nullptr); GLFWwindow * window = glfwCreateWindow(mode->width, mode->height, "RubiksCube", nullptr, nullptr); glfwMakeContextCurrent(window); while(!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glPushMatrix(); //window size chagne int width, height; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); glLoadIdentity(); gluPerspective(90, static_cast<double>(width) / static_cast<double>(height), 1, 128); gluLookAt(30, 30, 30, 0, 0, 0, 0, 1, 0); //view static int theta = 0; static int iota = 0; if (glfwGetKey(window, GLFW_KEY_RIGHT)) { ++theta; } if (glfwGetKey(window, GLFW_KEY_LEFT)) { --theta; } if (glfwGetKey(window, GLFW_KEY_UP)) { ++iota; } if (glfwGetKey(window, GLFW_KEY_DOWN)) { --iota; } static int index = 0; static bool key[256] = {}; for (int i = 0; i < 256; ++i) { if (glfwGetKey(window, static_cast<char>(i))) { if (!key[i]) { switch (static_cast<char>(i)) { case '1': index = 0; break; case '2': index = 1; break; case '3': index = 2; break; case 'X': rcc.rotate({{1,0,0}}, index, glfwGetKey(window, GLFW_KEY_LEFT_SHIFT)); break; case 'C': rcc.rotate({{0,1,0}}, index, glfwGetKey(window, GLFW_KEY_LEFT_SHIFT)); break; case 'Z': rcc.rotate({{0,0,1}}, index, glfwGetKey(window, GLFW_KEY_LEFT_SHIFT)); break; case 'R': { static std::mt19937 engine(std::random_device{}()); std::uniform_int_distribution<int> axis(0, 2); std::uniform_int_distribution<int> index(0, SIZE - 1); std::uniform_int_distribution<bool> isPrime(false, true); for (int i = 0; i < 128; ++i) { std::array<int, 3> a = {}; a[axis(engine)] = 1; rcc.rotate(a, index(engine), isPrime(engine)); } break; } default: break; } } key[i] = true; } else { key[i] = false; } } //view glRotated(theta, 0, 1, 0); glRotated(iota, 1, 0, 0); //centralize glTranslated(-(SIZE - 1) * 2, -(SIZE - 1) * 2, -(SIZE - 1) * 2); rcc.run(); rcc.draw(); glPopMatrix(); glfwSwapBuffers(window); glfwPollEvents(); } glfwTerminate(); }
int main(void) { Rectangle::Vector rectangles; rectangles.push_back(Rectangle(Position(0.3f, 0.7f), Dimension(1.0f, 0.2f), Speed(0.4f, 0.0f), Color(0.0f, 1.0f, 1.0f, 1.0f))); rectangles.push_back(Rectangle(Position(0.0f, 0.4f), Dimension(1.0f, 0.2f), Speed(0.1f, 0.0f), Color(0.0f, 0.0f, 1.0f, 1.0f))); rectangles.push_back(Rectangle(Position(-0.6f, 0.1f), Dimension(1.0f, 0.2f), Speed(0.6f, 0.0f), Color(0.0f, 1.0f, 0.0f, 1.0f))); rectangles.push_back(Rectangle(Position(-1.0f, -0.2f), Dimension(1.0f, 0.2f), Speed(0.5f, 0.0f), Color(1.0f, 0.0f, 0.0f, 1.0f))); rectangles.push_back(Rectangle(Position(-1.0f, -0.5f), Dimension(1.0f, 0.2f), Speed(0.2f, 0.0f), Color(1.0f, 0.0f, 1.0f, 1.0f))); rectangles.push_back(Rectangle(Position(-1.0f, -0.8f), Dimension(1.0f, 0.2f), Speed(0.3f, 0.0f), Color(1.0f, 1.0f, 0.0f, 1.0f))); GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) { exit(EXIT_FAILURE); } // Ask for SRGB linear to gama conversion buffer glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE); // Ask for vertical synch (not working) // glfwSwapInterval(1); // get the list of monitors (at least one monitor shall be detected) int monitorCount = 0; GLFWmonitor** pMonitorList = glfwGetMonitors (&monitorCount); assert(0 < monitorCount); // if there is only one monitor, use it, but if there is more than one, use the last one // (Oculus Rift is expected to be the second monitor, extending the primary one GLFWmonitor* pMonitor = pMonitorList[monitorCount-1]; // get the current screen resolution and colour depth of the choosen monitor const GLFWvidmode* pCurrentVideoMod = glfwGetVideoMode(pMonitor); int width = pCurrentVideoMod->width; int height = pCurrentVideoMod->height; std::cout << "fullscreen (" << width << " x " << height << ")\n"; // Open a fullscreen window on the last monitor window = glfwCreateWindow(width, height, "Simple example", pMonitor, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); // std::cout << "fullscreen (" << width << " x " << height << ")\n"; double currTime = glfwGetTime(); double prevTime = currTime; while (!glfwWindowShouldClose(window)) { // clear the buffer glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); currTime = glfwGetTime(); float ellapsedTime = static_cast<float>(currTime - prevTime); // std::cout << "ellapsedTime=" << ellapsedTime << std::endl; // move the rectangles based on ellapsed time for (Rectangle::Vector::iterator iRectangle = rectangles.begin(); iRectangle != rectangles.end(); ++iRectangle) { iRectangle->move(ellapsedTime); } // draw the rectangles for (Rectangle::Vector::iterator iRectangle = rectangles.begin(); iRectangle != rectangles.end(); ++iRectangle) { iRectangle->render(); } // Swap back & front buffers glfwSwapBuffers(window); glfwPollEvents(); prevTime = currTime; } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { GLFWwindow* window; GLuint vertex_buffer, vertex_shader, fragment_shader, program; GLint mvp_location, vpos_location, vcol_location; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); glfwSwapInterval(1); // NOTE: OpenGL error checks have been omitted for brevity glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); vertex_shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL); glCompileShader(vertex_shader); fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL); glCompileShader(fragment_shader); program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); mvp_location = glGetUniformLocation(program, "MVP"); vpos_location = glGetAttribLocation(program, "vPos"); vcol_location = glGetAttribLocation(program, "vCol"); glEnableVertexAttribArray(vpos_location); glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)0); glEnableVertexAttribArray(vcol_location); glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 2)); while (!glfwWindowShouldClose(window)) { float ratio; int width, height; mat4x4 m, p, mvp; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float)height; glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT); mat4x4_identity(m); mat4x4_rotate_Z(m, m, (float)glfwGetTime()); mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f); mat4x4_mul(mvp, p, m); glUseProgram(program); glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*)mvp); glDrawArrays(GL_TRIANGLES, 0, 3); glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(int, char**) { // Setup window glfwSetErrorCallback(error_callback); if (!glfwInit()) return 1; GLFWwindow* window = glfwCreateWindow(1280, 720, "ImGui OpenGL2 example", NULL, NULL); glfwMakeContextCurrent(window); glfwSwapInterval(1); // Enable vsync // Setup ImGui binding ImGui::CreateContext(); ImGuiIO& io = ImGui::GetIO(); (void)io; ImGui_ImplGlfwGL2_Init(window, true); //io.NavFlags |= ImGuiNavFlags_EnableKeyboard; // Enable Keyboard Controls // Setup style ImGui::StyleColorsDark(); //ImGui::StyleColorsClassic(); // Load Fonts // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them. // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple. // - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit). // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call. // - Read 'misc/fonts/README.txt' for more instructions and details. // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ ! //io.Fonts->AddFontDefault(); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f); //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese()); //IM_ASSERT(font != NULL); bool show_demo_window = true; bool show_another_window = false; ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f); // Main loop while (!glfwWindowShouldClose(window)) { // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs. // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application. // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application. // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags. glfwPollEvents(); ImGui_ImplGlfwGL2_NewFrame(); // 1. Show a simple window. // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets automatically appears in a window called "Debug". { static float f = 0.0f; static int counter = 0; ImGui::Text("Hello, world!"); // Display some text (you can use a format string too) ImGui::SliderFloat("float", &f, 0.0f, 1.0f); // Edit 1 float using a slider from 0.0f to 1.0f ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our windows open/close state ImGui::Checkbox("Another Window", &show_another_window); if (ImGui::Button("Button")) // Buttons return true when clicked (NB: most widgets return true when edited/activated) counter++; ImGui::SameLine(); ImGui::Text("counter = %d", counter); ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate); } // 2. Show another simple window. In most cases you will use an explicit Begin/End pair to name your windows. if (show_another_window) { ImGui::Begin("Another Window", &show_another_window); ImGui::Text("Hello from another window!"); if (ImGui::Button("Close Me")) show_another_window = false; ImGui::End(); } // 3. Show the ImGui demo window. Most of the sample code is in ImGui::ShowDemoWindow(). Read its code to learn more about Dear ImGui! if (show_demo_window) { ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiCond_FirstUseEver); // Normally user code doesn't need/want to call this because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly! ImGui::ShowDemoWindow(&show_demo_window); } // Rendering int display_w, display_h; glfwGetFramebufferSize(window, &display_w, &display_h); glViewport(0, 0, display_w, display_h); glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w); glClear(GL_COLOR_BUFFER_BIT); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound, but prefer using the GL3+ code. ImGui::Render(); ImGui_ImplGlfwGL2_RenderDrawData(ImGui::GetDrawData()); glfwSwapBuffers(window); } // Cleanup ImGui_ImplGlfwGL2_Shutdown(); ImGui::DestroyContext(); glfwTerminate(); return 0; }
bool World::Initialize(unsigned int windowWidth, unsigned int windowHeight, String windowName, bool antiAliasing, bool fullScreen, bool resizable) { if (_initialized) { return false; } _running = true; // Windows DLL locations #if defined(WIN32) && defined(ANGEL_RELEASE) String bitsPath = "bits"; char currentDir[MAX_PATH]; _getcwd(currentDir, MAX_PATH); String currDir(currentDir); StringList libs; #if !ANGEL_DISABLE_DEVIL libs.push_back("DevIL.dll"); libs.push_back("ILU.dll"); libs.push_back("ILUT.dll"); #endif #if ANGEL_DISABLE_FMOD libs.push_back("OpenAL32.dll"); #else libs.push_back("fmodex.dll"); #endif for (int i=0; i < libs.size(); i++) { String libstring = currDir + "\\" + bitsPath + "\\" + libs[i]; HMODULE work = LoadLibrary(libstring.c_str()); if (work == 0) { DWORD err = GetLastError(); _com_error error(err); LPCSTR errorText = error.ErrorMessage(); sysLog.Printf("ERROR: Couldn't load DLL (%s); %s", libs[i].c_str(), errorText); } } // does bits directory exist? DWORD dwAttrib = GetFileAttributes(bitsPath.c_str()); if (dwAttrib != INVALID_FILE_ATTRIBUTES && dwAttrib & FILE_ATTRIBUTE_DIRECTORY) { _chdir(bitsPath.c_str()); } #endif // General windowing initialization #if !ANGEL_MOBILE glfwInit(); #endif #if defined(__APPLE__) // Set up paths correctly in the .app bundle #if !ANGEL_MOBILE CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); char path[PATH_MAX]; if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX)) { sysLog.Log("ERROR: Problem setting up working directory! Probably nothing will work!"); } CFRelease(resourcesURL); chdir(path); chdir(".."); #if defined(ANGEL_DEBUG) // set paths to the local resources rather than the copied ones String fileName = __FILE__; String dirPath = fileName.substr(0, fileName.size() - String("Angel/Infrastructure/World.cpp").size()); CFURLRef exeURL = CFBundleCopyExecutableURL(mainBundle); char exePath[PATH_MAX]; if (!CFURLGetFileSystemRepresentation(exeURL, TRUE, (UInt8 *)exePath, PATH_MAX)) { sysLog.Log("ERROR: Problem setting up working directory! Probably nothing will work!"); } CFRelease(exeURL); chdir(dirPath.c_str()); StringList pathElements = SplitString(exePath, "/"); String exeName = pathElements[pathElements.size()-1]; chdir(exeName.c_str()); #endif #else CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); char path[PATH_MAX]; if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX)) { std::cout << "Problem setting up working directory! Probably nothing will work!" << std::endl; } CFRelease(resourcesURL); chdir(path); chdir("Angel"); // the iPhone doesn't like having a "Resources" directory in the root of the .app bundle #endif #endif //Start scripting LuaScriptingModule::Prep(); //Reset values based on preferences antiAliasing = thePrefs.OverrideInt("WindowSettings", "antiAliasing", antiAliasing); fullScreen = thePrefs.OverrideInt("WindowSettings", "fullScreen", fullScreen); resizable = thePrefs.OverrideInt("WindowSettings", "resizable", resizable); windowHeight = thePrefs.OverrideInt("WindowSettings", "height", windowHeight); windowWidth = thePrefs.OverrideInt("WindowSettings", "width", windowWidth); windowName = thePrefs.OverrideString("WindowSettings", "name", windowName); //Windowing system setup #if !ANGEL_MOBILE if (antiAliasing) { glfwWindowHint(GLFW_SAMPLES, 4); //4x looks pretty good _antiAliased = true; } else { _antiAliased = false; } GLFWmonitor* openOn = NULL; // windowed if (fullScreen) { openOn = glfwGetPrimaryMonitor(); } if (resizable) { glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); } else { glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); } _mainWindow = glfwCreateWindow(windowWidth, windowHeight, windowName.c_str(), openOn, NULL); glfwMakeContextCurrent(_mainWindow); int fbw, fbh; glfwGetFramebufferSize(_mainWindow, &fbw, &fbh); if (fbw == windowWidth * 2) { SetHighResolutionScreen(true); } #if defined(WIN32) glfwSwapInterval(0); // because double-buffering and Windows don't get along apparently #else glfwSwapInterval(1); #endif glfwSetWindowSizeCallback(_mainWindow, Camera::ResizeCallback); glfwSetKeyCallback(_mainWindow, keyboardInput); glfwSetCharCallback(_mainWindow, charInput); glfwSetCursorPosCallback(_mainWindow, MouseMotion); glfwSetMouseButtonCallback(_mainWindow, MouseButton); glfwSetScrollCallback(_mainWindow, MouseWheel); glfwSetWindowCloseCallback(_mainWindow, windowClosed); _prevTime = glfwGetTime(); Camera::ResizeCallback(_mainWindow, fbw, fbh); #else struct timeval tv; gettimeofday(&tv, NULL); _currTime = _startTime = tv.tv_sec + (double) tv.tv_usec / 1000000.0; #endif //OpenGL state setup #if !ANGEL_MOBILE glClearDepth(1.0f); glPolygonMode(GL_FRONT, GL_FILL); #else glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(1.0f, -1.0f); #endif glShadeModel(GL_FLAT); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); glCullFace(GL_BACK); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearStencil(0); glClearColor(1.0f, 1.0f, 1.0f, 1.0f); //Get textures going InitializeTextureLoading(); //Subscribe to camera changes theSwitchboard.SubscribeTo(this, "CameraChange"); //initialize singletons #if !ANGEL_MOBILE theInput; theControllerManager.Setup(); #endif theSound; theSpatialGraph; #if !ANGEL_MOBILE RegisterConsole(new TestConsole()); #else // register fonts, since we don't have the console doing it for us on the phone RegisterFont("Resources/Fonts/Inconsolata.otf", 24, "Console"); RegisterFont("Resources/Fonts/Inconsolata.otf", 18, "ConsoleSmall"); #endif LuaScriptingModule::Initialize(); return _initialized = true; }
int main(void) { GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); window = glfwCreateWindow(1024, 768, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); // Initialize GLEW glewExperimental = true; // Needed for core profile if (glewInit() != GLEW_OK) { fprintf(stderr, "Failed to initialize GLEW\n"); return -1; } // Create and compile our GLSL program from the shaders GLuint programID = LoadShaders( "../resources/shaders/SimpleVertexShader.vertexshader", "../resources/shaders/SimpleFragmentShader.fragmentshader" ); initGL(); Tunnel *myTunnel = new Tunnel(vec3(0.0f,0.0f,1.0f), 2, 1.0f, 1.0f); Tunnel myTunnel2 = Tunnel(vec3(0.0f,0.0f,-3.0f), 2, 1.0f, 1.0f); for (int i=0; i<10; i++){ Cube3d *myCube = new Cube3d(0.5f, vec3(0.0f,0.0f,(GLfloat) -i)); myCubeVect.push_back(myCube); } //Cube3d *myCube = new Cube3d(0.5f); while (!glfwWindowShouldClose(window)) { playerPos = (int) camPosZ; int index = playerPos; if(index>10){ int div = (int) playerPos/10; index = playerPos - div*10; } // printf("playerPos=%d; index=%d\n", playerPos, index); if (index>0) { myCubeVect[index-1]->setTranslation(vec3(0.0f,0.0f,-10.0f)); } //myCube2->setTranslation(vec3(0.0f,0.0f,-playerPos)); /* Clear The Screen And The Depth Buffer */ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); float ratio; int width, height; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float) height; glViewport(0, 0, width, height); // glClear(GL_COLOR_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); /* Set our perspective */ gluPerspective( 45.0f, ratio, 0.1f, 500.0f ); //glOrtho(-ratio, ratio, -1.f, 1.f, 1.f, -1.f); //gluOrtho2D( 0,width,0,height ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glLoadIdentity(); glRotatef(camRotY, 0.0f, 1.0f, 0.0f); //glTranslatef(0, 0, 5); glTranslatef(camPosX, camPosY, camPosZ); //>>>>>>>>>>>>>>>>>>START drawing our level<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< /*for(int i=0; i<myCubeVect.size(); ++i) { myCubeVect[i]->draw(); }*/ myTunnel->draw(); myTunnel2.draw(); /*glBegin(GL_LINES); glVertex3f(0.0f, 1.0f, 0.0f); glVertex3f(sinf(pi/4), cosf(pi/4),0.0f); glVertex3f(sinf(pi/4), cosf(pi/4),0.0f); glVertex3f(sinf(pi/2), cosf(pi/2),0.0f); glVertex3f(sinf(pi/2), cosf(pi/2),0.0f); glVertex3f(sinf(3*pi/4), cosf(3*pi/4),0.0f); glVertex3f(sinf(3*pi/4), cosf(3*pi/4),0.0f); glVertex3f(sinf(pi), cosf(pi),0.0f); glEnd();*/ rotTri+=3.0f; glfwSwapBuffers(window); glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(){ std::string vertex_string = read_shader("vertex.glsl"); std::string fragment_string = read_shader("fragment.glsl"); const GLchar* vertexShaderSource = vertex_string.c_str(); const GLchar* fragmentShaderSource = fragment_string.c_str(); // Initializing glfw for window generation glfwInit(); // Setting window variables glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Generating window instance GLFWwindow *window = glfwCreateWindow(800, 600, "Hello World", nullptr, nullptr); if (window == nullptr){ std::cout << "Window could not be created!" << '\n'; glfwTerminate(); return(-1); } glfwMakeContextCurrent(window); // GLEW manages function pointers for OpenGL // GL_TRUE gives us a more modern GLEW to work with glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK){ std::cout << "Failed to initialize GLEW" << '\n'; } // Setting viewport up so OpenGL knows what to draw to and where int width, height; glfwGetFramebufferSize(window, &width, &height); // Read from LL to UR // Here, we map -1 < x < 1 in x and y to 800 x 600 glViewport(0,0,width,height); // Registering closing callback function // glfwPollEvents later should be waiting for key callbacks glfwSetKeyCallback(window, key_callback); // Building / compiling shader program GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); // Check for errors GLint success; GLchar infoLog[512]; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (!success){ glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); std::cout << "ERROR: vertex shader compilation failed!" << '\n'; } // Now the same for the Fragment shader GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); // Check for fragment shader errors glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); if (!success){ glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog); std::cout << "ERROR: fragment shader compilation failed!" << '\n'; } // Now to link the shaders together GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); // Checking for linking errors glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); if (!success){ glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog); std::cout << "ERROR: program linking failed!" << '\n'; } // Removing shaders after program is built glDeleteShader(vertexShader); glDeleteShader(fragmentShader); // Rendering a triangle.. first, we need to define the vertices // Note: GL assumes 3 dimensions, and likely parses the vertices by groups // of three. int max_depth = 4; std::vector<vec> vertices; vertices.reserve(3 * pow(4,max_depth)); std::vector<triangle> indices; indices.reserve(pow(4,max_depth)); //create_triangle_vertex(vertices, indices, 4096); //std::vector<vec> init_corners(3); vec init_corners[3]; init_corners[0] = vec(0,1,0); init_corners[1] = vec(-1,-1,-1); init_corners[2] = vec(1,-1,1); divide_triangle(init_corners, indices, vertices, max_depth); // Now to request space on the GPU with Vertex Buffer Objects (VBO) // VAO is Vertex Array Object // Buffer has a unique ID GLuint VBO, VAO, EBO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glGenBuffers(1, &EBO); // Binding VAO first glBindVertexArray(VAO); // Specify the type of buffer: glBindBuffer(GL_ARRAY_BUFFER, VBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); // Now to do the copying // GL_STATIC_DRAW: No changes in vertices expected // GL_DYNAMIC_DRAW: Regular changes expected // GL_STREAM_DRAW: Changes expected every step glBufferData(GL_ARRAY_BUFFER, vertices.size() * 3 * sizeof(float), vertices.data(), GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * 3 * sizeof(int), indices.data(), GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBindVertexArray(0); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Called a "game loop" continues until window needs to close while (!glfwWindowShouldClose(window)) { glfwPollEvents(); // Render // Clear the color buffer glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // Using the program we created glUseProgram(shaderProgram); // Create transformations glm::mat4 model; glm::mat4 view; glm::mat4 projection; model = glm::rotate(model, -55.0f, glm::vec3(1.0f, 0.0f, 0.0f)); view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f)); projection = glm::perspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f); // Get their uniform location GLint modelLoc = glGetUniformLocation(shaderProgram, "model"); GLint viewLoc = glGetUniformLocation(shaderProgram, "view"); GLint projLoc = glGetUniformLocation(shaderProgram, "projection"); // Pass them to the shaders glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); // Draw container glBindVertexArray(VAO); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); } /* while (!glfwWindowShouldClose(window)){ glfwPollEvents(); // Setting window color and such: glClearColor(0.2f, 0.3f, 0.3f, 0.5f); glClear(GL_COLOR_BUFFER_BIT); // Using the program we created glUseProgram(shaderProgram); glm:: mat4 view, projection, model; model = glm::rotate(model, 55.0f, glm::vec3(1.0f, 0.0f, 0.0f)); projection = glm::perspective(55.0f, (float)width / (float)height, 0.1f, 100.0f); view = glm::translate(view, glm::vec3(0.0f, 0.0f, 3.0f)); GLint modelLoc = glGetUniformLocation(shaderProgram, "model"); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); GLint viewLoc = glGetUniformLocation(shaderProgram, "view"); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); GLint projLoc = glGetUniformLocation(shaderProgram, "projection"); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); glBindVertexArray(VAO); //glDrawArrays(GL_TRIANGLES, 0, 3); glDrawElements(GL_TRIANGLES, indices.size() * 3, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glfwSwapBuffers(window); } */ // termination glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); glDeleteBuffers(1, &EBO); glfwTerminate(); }
// The MAIN function, from here we start our application and run our Game loop int main() { // Init GLFW glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // Initialize GLEW to setup the OpenGL Function pointers glewExperimental = GL_TRUE; glewInit(); // Define the viewport dimensions int width, height; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); // Setup some OpenGL options glEnable(GL_DEPTH_TEST); // Setup and compile our shaders Shader shader("bloom.vs", "bloom.frag"); Shader shaderLight("bloom.vs", "light_box.frag"); Shader shaderBlur("blur.vs", "blur.frag"); Shader shaderBloomFinal("bloom_final.vs", "bloom_final.frag"); // Set samplers shaderBloomFinal.Use(); glUniform1i(glGetUniformLocation(shaderBloomFinal.Program, "scene"), 0); glUniform1i(glGetUniformLocation(shaderBloomFinal.Program, "bloomBlur"), 1); // Light sources // - Positions std::vector<glm::vec3> lightPositions; lightPositions.push_back(glm::vec3(0.0f, 0.5f, 1.5f)); // back light lightPositions.push_back(glm::vec3(-4.0f, 0.5f, -3.0f)); lightPositions.push_back(glm::vec3(3.0f, 0.5f, 1.0f)); lightPositions.push_back(glm::vec3(-.8f, 2.4f, -1.0f)); // - Colors std::vector<glm::vec3> lightColors; lightColors.push_back(glm::vec3(5.0f, 5.0f, 5.0f)); lightColors.push_back(glm::vec3(5.5f, 0.0f, 0.0f)); lightColors.push_back(glm::vec3(0.0f, 0.0f, 15.0f)); lightColors.push_back(glm::vec3(0.0f, 1.5f, 0.0f)); // Load textures GLuint woodTexture = loadTexture(FileSystem::getPath("resources/textures/wood.png").c_str()); GLuint containerTexture = loadTexture(FileSystem::getPath("resources/textures/container2.png").c_str()); // Set up floating point framebuffer to render scene to GLuint hdrFBO; glGenFramebuffers(1, &hdrFBO); glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO); // - Create 2 floating point color buffers (1 for normal rendering, other for brightness treshold values) GLuint colorBuffers[2]; glGenTextures(2, colorBuffers); for (GLuint i = 0; i < 2; i++) { glBindTexture(GL_TEXTURE_2D, colorBuffers[i]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // We clamp to the edge as the blur filter would otherwise sample repeated texture values! glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // attach texture to framebuffer glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, colorBuffers[i], 0); } // - Create and attach depth buffer (renderbuffer) GLuint rboDepth; glGenRenderbuffers(1, &rboDepth); glBindRenderbuffer(GL_RENDERBUFFER, rboDepth); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, SCR_WIDTH, SCR_HEIGHT); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth); // - Tell OpenGL which color attachments we'll use (of this framebuffer) for rendering GLuint attachments[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 }; glDrawBuffers(2, attachments); // - Finally check if framebuffer is complete if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "Framebuffer not complete!" << std::endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); // Ping pong framebuffer for blurring GLuint pingpongFBO[2]; GLuint pingpongColorbuffers[2]; glGenFramebuffers(2, pingpongFBO); glGenTextures(2, pingpongColorbuffers); for (GLuint i = 0; i < 2; i++) { glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[i]); glBindTexture(GL_TEXTURE_2D, pingpongColorbuffers[i]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // We clamp to the edge as the blur filter would otherwise sample repeated texture values! glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, pingpongColorbuffers[i], 0); // Also check if framebuffers are complete (no need for depth buffer) if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "Framebuffer not complete!" << std::endl; } glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Game loop while (!glfwWindowShouldClose(window)) { // Set frame time GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check and call events glfwPollEvents(); Do_Movement(); // 1. Render scene into floating point framebuffer glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)SCR_WIDTH / (GLfloat)SCR_HEIGHT, 0.1f, 100.0f); glm::mat4 view = camera.GetViewMatrix(); glm::mat4 model; shader.Use(); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, woodTexture); // - set lighting uniforms for (GLuint i = 0; i < lightPositions.size(); i++) { glUniform3fv(glGetUniformLocation(shader.Program, ("lights[" + std::to_string(i) + "].Position").c_str()), 1, &lightPositions[i][0]); glUniform3fv(glGetUniformLocation(shader.Program, ("lights[" + std::to_string(i) + "].Color").c_str()), 1, &lightColors[i][0]); } glUniform3fv(glGetUniformLocation(shader.Program, "viewPos"), 1, &camera.Position[0]); // - create one large cube that acts as the floor model = glm::mat4(); model = glm::translate(model, glm::vec3(0.0f, -1.0f, 0.0)); model = glm::scale(model, glm::vec3(25.0f, 1.0f, 25.0f)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); // - then create multiple cubes as the scenery glBindTexture(GL_TEXTURE_2D, containerTexture); model = glm::mat4(); model = glm::translate(model, glm::vec3(0.0f, 1.5f, 0.0)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); model = glm::mat4(); model = glm::translate(model, glm::vec3(2.0f, 0.0f, 1.0)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); model = glm::mat4(); model = glm::translate(model, glm::vec3(-1.0f, -1.0f, 2.0)); model = glm::rotate(model, 60.0f, glm::normalize(glm::vec3(1.0, 0.0, 1.0))); model = glm::scale(model, glm::vec3(2.0)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); model = glm::mat4(); model = glm::translate(model, glm::vec3(0.0f, 2.7f, 4.0)); model = glm::rotate(model, 23.0f, glm::normalize(glm::vec3(1.0, 0.0, 1.0))); model = glm::scale(model, glm::vec3(2.5)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); model = glm::mat4(); model = glm::translate(model, glm::vec3(-2.0f, 1.0f, -3.0)); model = glm::rotate(model, 124.0f, glm::normalize(glm::vec3(1.0, 0.0, 1.0))); model = glm::scale(model, glm::vec3(2.0)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); RenderCube(); model = glm::mat4(); model = glm::translate(model, glm::vec3(-3.0f, 0.0f, 0.0)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); RenderCube(); // - finally show all the light sources as bright cubes shaderLight.Use(); glUniformMatrix4fv(glGetUniformLocation(shaderLight.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); glUniformMatrix4fv(glGetUniformLocation(shaderLight.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); for (GLuint i = 0; i < lightPositions.size(); i++) { model = glm::mat4(); model = glm::translate(model, glm::vec3(lightPositions[i])); model = glm::scale(model, glm::vec3(0.5f)); glUniformMatrix4fv(glGetUniformLocation(shaderLight.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glUniform3fv(glGetUniformLocation(shaderLight.Program, "lightColor"), 1, &lightColors[i][0]); RenderCube(); } glBindFramebuffer(GL_FRAMEBUFFER, 0); // 2. Blur bright fragments w/ two-pass Gaussian Blur GLboolean horizontal = true, first_iteration = true; GLuint amount = 10; shaderBlur.Use(); for (GLuint i = 0; i < amount; i++) { glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[horizontal]); glUniform1i(glGetUniformLocation(shaderBlur.Program, "horizontal"), horizontal); glBindTexture(GL_TEXTURE_2D, first_iteration ? colorBuffers[1] : pingpongColorbuffers[!horizontal]); // bind texture of other framebuffer (or scene if first iteration) RenderQuad(); horizontal = !horizontal; if (first_iteration) first_iteration = false; } glBindFramebuffer(GL_FRAMEBUFFER, 0); // 2. Now render floating point color buffer to 2D quad and tonemap HDR colors to default framebuffer's (clamped) color range glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderBloomFinal.Use(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, colorBuffers[0]); //glBindTexture(GL_TEXTURE_2D, pingpongColorbuffers[!horizontal]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, pingpongColorbuffers[!horizontal]); glUniform1i(glGetUniformLocation(shaderBloomFinal.Program, "bloom"), bloom); glUniform1f(glGetUniformLocation(shaderBloomFinal.Program, "exposure"), exposure); RenderQuad(); // Swap the buffers glfwSwapBuffers(window); } glfwTerminate(); return 0; }
GLFWView::GLFWView(bool fullscreen_, bool benchmark_) : fullscreen(fullscreen_), benchmark(benchmark_) { glfwSetErrorCallback(glfwError); std::srand(std::time(0)); if (!glfwInit()) { mbgl::Log::Error(mbgl::Event::OpenGL, "failed to initialize glfw"); exit(1); } GLFWmonitor *monitor = nullptr; if (fullscreen) { monitor = glfwGetPrimaryMonitor(); auto videoMode = glfwGetVideoMode(monitor); width = videoMode->width; height = videoMode->height; } #ifdef DEBUG glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); #endif #ifdef GL_ES_VERSION_2_0 glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); #endif glfwWindowHint(GLFW_RED_BITS, 8); glfwWindowHint(GLFW_GREEN_BITS, 8); glfwWindowHint(GLFW_BLUE_BITS, 8); glfwWindowHint(GLFW_ALPHA_BITS, 8); glfwWindowHint(GLFW_STENCIL_BITS, 8); glfwWindowHint(GLFW_DEPTH_BITS, 16); window = glfwCreateWindow(width, height, "Mapbox GL", monitor, NULL); if (!window) { glfwTerminate(); mbgl::Log::Error(mbgl::Event::OpenGL, "failed to initialize window"); exit(1); } glfwSetWindowUserPointer(window, this); glfwMakeContextCurrent(window); if (benchmark) { // Disables vsync on platforms that support it. glfwSwapInterval(0); } else { glfwSwapInterval(1); } glfwSetCursorPosCallback(window, onMouseMove); glfwSetMouseButtonCallback(window, onMouseClick); glfwSetWindowSizeCallback(window, onWindowResize); glfwSetFramebufferSizeCallback(window, onFramebufferResize); glfwSetScrollCallback(window, onScroll); glfwSetKeyCallback(window, onKey); mbgl::gl::InitializeExtensions(glfwGetProcAddress); glfwGetWindowSize(window, &width, &height); glfwGetFramebufferSize(window, &fbWidth, &fbHeight); pixelRatio = static_cast<float>(fbWidth) / width; glfwMakeContextCurrent(nullptr); }
bool EGLView::init(const char* viewName, float width, float height, float frameZoomFactor) { if(nullptr != _mainWindow) return true; setViewName(viewName); setFrameSize(width, height); setFrameZoomFactor(frameZoomFactor); glfwWindowHint(GLFW_RESIZABLE,GL_FALSE); _mainWindow = glfwCreateWindow(_screenSize.width * _frameZoomFactor, _screenSize.height * _frameZoomFactor, _viewName, nullptr, nullptr); glfwMakeContextCurrent(_mainWindow); glfwGetFramebufferSize(_mainWindow, &_frameBufferSize[0], &_frameBufferSize[1]); glfwSetMouseButtonCallback(_mainWindow,EGLViewEventHandler::OnGLFWMouseCallBack); glfwSetCursorPosCallback(_mainWindow,EGLViewEventHandler::OnGLFWMouseMoveCallBack); glfwSetCharCallback(_mainWindow, EGLViewEventHandler::OnGLFWCharCallback); glfwSetKeyCallback(_mainWindow, EGLViewEventHandler::OnGLFWKeyCallback); glfwSetWindowPosCallback(_mainWindow, EGLViewEventHandler::OnGLFWWindowPosCallback); // check OpenGL version at first const GLubyte* glVersion = glGetString(GL_VERSION); CCLOG("OpenGL version = %s", glVersion); if ( atof((const char*)glVersion) < 1.5 ) { char strComplain[256] = {0}; sprintf(strComplain, "OpenGL 1.5 or higher is required (your version is %s). Please upgrade the driver of your video card.", glVersion); MessageBox(strComplain, "OpenGL version too old"); return false; } GLenum GlewInitResult = glewInit(); if (GLEW_OK != GlewInitResult) { MessageBox((char *)glewGetErrorString(GlewInitResult), "OpenGL error"); return false; } if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader) { log("Ready for GLSL"); } else { log("Not totally ready :("); } if (glewIsSupported("GL_VERSION_2_0")) { log("Ready for OpenGL 2.0"); } else { log("OpenGL 2.0 not supported"); } // if(glew_dynamic_binding() == false) // { // MessageBox("No OpenGL framebuffer support. Please upgrade the driver of your video card.", "OpenGL error"); // return false; // } // // Enable point size by default on windows. glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); return true; }
int main() { if (!glfwInit()) { return -1; } GLFWwindow *window = setup_window(640, 480, "Hellurr!!"); glewExperimental = GL_TRUE; glewInit(); // Create Vertex buffer object, containing our 4 vertices. // This allows us to draw a full screen quad, so we can // later on do raycasting in the fragment shader GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // Compile shaders. The vertex shader is just pass-through char *f_shader_source = read_file("default.frag"); GLuint v_shader = compile_shader(vertex_shader, GL_VERTEX_SHADER); GLuint f_shader = compile_shader((const char *)f_shader_source, GL_FRAGMENT_SHADER); GLuint program = create_program(v_shader, f_shader); free((void *)f_shader_source); // Bind shader attributes with a vertex array object GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLint vertex_handle = glGetAttribLocation(program, "in_vertex"); glVertexAttribPointer(vertex_handle, 2, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(vertex_handle); // Pass the frame buffer size to the fragment shader int width, height; glfwGetFramebufferSize(window, &width, &height); GLint size_handle = glGetUniformLocation(program, "buffer_size"); glUniform2i(size_handle, width, height); GLint cursor_handle = glGetUniformLocation(program, "mouse_position"); // Enable vsync glfwSwapInterval(1); // Loop until the user closes the window while (!glfwWindowShouldClose(window)) { double xpos, ypos; glfwGetCursorPos(window, &xpos, &ypos); glUniform2f(cursor_handle, xpos / 640, ypos / 480); // Draw our full screen quad glBindVertexArray(vao); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); // Swap front and back buffers glfwSwapBuffers(window); glfwPollEvents(); } glfwTerminate(); return 0; }
int main(int argc, char *argv[]) { // Les seuls et uniques paramètres à modifier si on veut changer ce que le programme fait !!!!! int theProgramMode = NOPLOT_MODE; // PLOT_MODE || NOPLOT_MODE int nmax = 100; // nombre d'itération maximale > nsub int nsub = 25; // Nombre d'itération entre chaque enregistrement de parametres double dt = 5; // timeStep const char *name = "tsunamiMedium"; // Nom du fichier pour la lecture char meshfile[256]; char data[256]; const char *mesh = "%s.txt"; const char *database = "data/%s-%04.0f"; sprintf(meshfile,mesh,name); sprintf(data,database,name, dt); //const char *meshfile = "tsunamiSmall.txt"; // Pour calculer un nouveau tsunami (PLOT_MODE) //const char *data = "data/tsunamiSmall"; // Tusnami à lire (NOPLOT_MODE) // // Options possibles // -noplot : version non graphique avec creation de fichiers de resultats // -plot : lecture des fichiers et animation // (par défaut) : version graphique interactive // // // Options graphiques // B = montre la bathymétrie // E = montre l'elevation // V = zoom sur le japon (3 vues possibles) // // while(argc--) { if (strcmp( *argv, "-noplot" ) == 0) theProgramMode = NOPLOT_MODE; if (strcmp( *argv++, "-plot" ) == 0) theProgramMode = PLOT_MODE; } if (theProgramMode == NOPLOT_MODE) { printf("Computing the tsunami : be patient :-) \n"); tsunamiCompute(dt,nmax,nsub,meshfile,data); theProgramMode = PLOT_MODE; } if (theProgramMode == PLOT_MODE) { int nElem,nNode,i,j,index,trash,*elem; double *X,*Y,*H,*E,*U,*V; double value = 0; int width,height; double t; double R = 6371220; double BathMax = 9368; GLfloat colors[9], coord[9]; int theZoom = 0; int thePlot = -1; FILE* file = fopen(meshfile,"r"); if (file == NULL) { printf("Error : cannot open mesh file :-) \n"); exit(0); } if (!fscanf(file, "Number of nodes %d \n", &nNode)) exit(-1); X = malloc(sizeof(double)*nNode); Y = malloc(sizeof(double)*nNode); H = malloc(sizeof(double)*nNode); for (i = 0; i < nNode; i++) if (!fscanf(file,"%d : %le %le %le \n",&trash,&X[i],&Y[i],&H[i])) exit(-1); if (!fscanf(file, "Number of triangles %d \n", &nElem)) exit(-1); elem = malloc(sizeof(int)*3*nElem); E = malloc(sizeof(double)*3*nElem); U = malloc(sizeof(double)*3*nElem); V = malloc(sizeof(double)*3*nElem); for (i = 0; i < nElem; i++) if (!fscanf(file,"%d : %d %d %d \n", &trash,&elem[i*3],&elem[i*3+1],&elem[i*3+2])) exit(-1); fclose(file); glfwInit(); GLFWwindow* window = glfwCreateWindow(480,480,"MECA1120 : Tsunami",NULL,NULL); glfwMakeContextCurrent(window); glShadeModel(GL_SMOOTH); glfwSwapInterval(1); GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 0.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[] = { 8.0, 8.0, 8.0, 0.0 }; glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glLightfv(GL_LIGHT0, GL_POSITION, light_position); GLfloat light_radiance[] = {1.0, 1.0, 1.0, 1.0}; glLightfv(GL_LIGHT0, GL_DIFFUSE, light_radiance); glLightfv(GL_LIGHT0, GL_SPECULAR, light_radiance); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glEnable(GL_COLOR_MATERIAL); glEnable(GL_NORMALIZE); int frame=0; do { t = glfwGetTime(); frame++; frame = frame%(nmax/nsub+1); if (thePlot == 1) { char filename[256]; const char *basename = "%s-%08d.txt"; sprintf(filename, basename, data, frame * nsub); if (access(filename, F_OK)) { // mais à quoi sert cette ligne ? } else { printf("=== Reading local file %s %d %f \n",filename,frame,t); tsunamiReadFile(data,frame*nsub,U,V,E,nElem); }} glfwGetFramebufferSize(window,&width,&height); height = height > 0 ? height : 1; glViewport( 0, 0, width, height ); glClearColor( 0.9f, 0.9f, 0.8f, 0.0f ); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(65.0f,(GLfloat)width/(GLfloat)height,1.0f,100.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0f,1.0f,0.0f,0.0f, 20.0f, 0.0f,0.0f,0.0f,1.0f); if (theZoom == 0) glTranslatef(0.0f,14.0f,0.0f); // Vue terre complete if (theZoom == 1) glTranslatef(0.0f,9.0f,-3.0f); // Vue zoom moyen if (theZoom == 2) glTranslatef(1.0f,7.0f,-4.0f); // Vue zoom rapproche double alpha = 389; double beta = 0; glRotatef(0.3f*(GLfloat)alpha + (GLfloat)beta*10.0f,0.0f,0.0f,1.0f); // A commenter pour supprimer la sphere interieure // Conseille pour les maillages grossiers :-) GLUquadricObj *quadratic = gluNewQuadric(); gluQuadricNormals(quadratic, GLU_SMOOTH); glColor3f(1.0,1.0,1.0); gluSphere(quadratic,5.95,400,200); for (i=0; i < nElem; ++i) { for (j=0; j < 3; ++j) { index = elem[3*i+j]; if (thePlot == -1) value = H[index]/BathMax; if (thePlot == 1) value = E[3*i+j]*10; if (value < 0) value = 0; if (value > 1) value = 1; colors[j*3+0] = 3.5*(value)*(value); colors[j*3+1] = (1-value)*(value)*3.5; colors[j*3+2] = (1-value)*(1-value); double x = X[index]; double y = Y[index]; double Factor = (4*R*R + x*x + y*y)*(R/6); coord[j*3+0] = 4*R*R * x / Factor; coord[j*3+1] = 4*R*R * y / Factor; coord[j*3+2] = (4*R*R - x*x - y*y)*R / Factor; } glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glVertexPointer(3, GL_FLOAT, 0, coord); glNormalPointer(GL_FLOAT, 0, coord); glColorPointer(3, GL_FLOAT, 0, colors); glDrawArrays(GL_TRIANGLES, 0, 3); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glColor3f(0.0, 0.0, 0.0); glEnableClientState(GL_VERTEX_ARRAY); for (j=0; j < 9; ++j) coord[j] = coord[j] * 1.001; glVertexPointer(3, GL_FLOAT, 0, coord); glDrawArrays(GL_LINE_LOOP, 0, 3); glDisableClientState(GL_VERTEX_ARRAY); } if (glfwGetKey(window,'V') == GLFW_PRESS) theZoom = (theZoom + 1) % 3; if (glfwGetKey(window,'E') == GLFW_PRESS) {thePlot = 1; } if (glfwGetKey(window,'B') == GLFW_PRESS) thePlot = -1; glfwSwapBuffers(window); glfwPollEvents(); } while( glfwGetKey(window,GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) != 1 ); glfwTerminate(); free(E); free(U); free(V); free(H); free(X); free(Y); free(elem); exit( EXIT_SUCCESS ); } }
/*/////////////////////// // Public Functions // ///////////////////////*/ int main(int argc, char **argv) { GLFWwindow *window = NULL; UNUSED_ARG(argc); UNUSED_ARG(argv); // initialize GLFW, our platform abstraction library. glfwSetErrorCallback(glfw_error); if (!glfwInit()) { exit(EXIT_FAILURE); } glfwWindowHint(GLFW_VISIBLE, GL_TRUE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); #if GL_DEBUG_ENABLE glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); #endif // create the main application window and OpenGL context. window = glfwCreateWindow(GW_WINDOW_WIDTH, GW_WINDOW_HEIGHT, GW_WINDOW_TITLE, NULL, NULL); if (window == NULL) { fprintf(stderr, "ERROR: Cannot create primary GLFW window.\n"); glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); // now that we have an OpenGL context, load extensions provided by the platform. // note that glewExperimental is defined by the GLEW library and is required on // OSX or the glGenVertexArrays() call will cause a fault. glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { fprintf(stderr, "ERROR: Cannot initialize GLEW for the primary context.\n"); glfwTerminate(); exit(EXIT_FAILURE); } // clear any OpenGL error status and configure debug output. glGetError(); #if GL_DEBUG_ENABLE if (GLEW_ARB_debug_output) { glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); glDebugMessageCallbackARB(gl_arb_debug, NULL); } #endif // initialize global managers: gDisplayManager = new DisplayManager(); gDisplayManager->Init(window); gInputManager = new InputManager(); gInputManager->Init(window); Player *player = new Player(0); player->Init(gDisplayManager); gEntityManager = new EntityManager(); gEntityManager->AddEntity(player); // game loop setup and run: const double Step = GW_SIM_TIMESTEP; double previousTime = glfwGetTime(); double currentTime = previousTime; double elapsedTime = 0.0; double accumulator = 0.0; double simTime = 0.0; double t = 0.0; int width = 0; int height = 0; while (!glfwWindowShouldClose(window)) { // retrieve the current framebuffer size, which // may be different from the current window size. glfwGetFramebufferSize(window, &width, &height); // update the main game clock. previousTime = currentTime; currentTime = glfwGetTime(); elapsedTime = currentTime - previousTime; if (elapsedTime > GW_MAX_TIMESTEP) { elapsedTime = GW_MAX_TIMESTEP; } if (elapsedTime < GW_MIN_TIMESTEP) { elapsedTime = GW_MIN_TIMESTEP; } accumulator += elapsedTime; // process user input at the start of the frame. input(currentTime, elapsedTime); // execute the simulation zero or more times per-frame. // the simulation runs at a fixed timestep. while (accumulator >= Step) { // @todo: swap game state buffers here. // pass the current game state to simulate. simulate(simTime, Step); accumulator -= Step; simTime += Step; } // interpolate display state. t = accumulator / Step; // state = currentState * t + previousState * (1.0 - t); render(currentTime, elapsedTime, t, width, height); // now present the current frame and process OS events. glfwSwapBuffers(window); glfwPollEvents(); } // teardown global managers. delete gEntityManager; delete gDisplayManager; delete gInputManager; // perform any top-level cleanup. glfwTerminate(); exit(EXIT_SUCCESS); }
void ImGui_ImplGlfwGL3_NewFrame() { int fboW, fboH; glfwGetFramebufferSize(g_Window, &fboW, &fboH); ImGui_ImplGlfwGL3_NewFrame(fboW, fboH); }
int main(int argc, char** argv) { int ch, width, height; thrd_t physics_thread = 0; GLFWwindow* window; GLFWmonitor* monitor = NULL; if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(EXIT_FAILURE); } while ((ch = getopt(argc, argv, "fh")) != -1) { switch (ch) { case 'f': monitor = glfwGetPrimaryMonitor(); break; case 'h': usage(); exit(EXIT_SUCCESS); } } if (monitor) { const GLFWvidmode* mode = glfwGetVideoMode(monitor); glfwWindowHint(GLFW_RED_BITS, mode->redBits); glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits); glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits); glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate); width = mode->width; height = mode->height; } else { width = 640; height = 480; } window = glfwCreateWindow(width, height, "Particle Engine", monitor, NULL); if (!window) { fprintf(stderr, "Failed to create GLFW window\n"); glfwTerminate(); exit(EXIT_FAILURE); } if (monitor) glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwSwapInterval(1); glfwSetFramebufferSizeCallback(window, resize_callback); glfwSetKeyCallback(window, key_callback); // Set initial aspect ratio glfwGetFramebufferSize(window, &width, &height); resize_callback(window, width, height); // Upload particle texture glGenTextures(1, &particle_tex_id); glBindTexture(GL_TEXTURE_2D, particle_tex_id); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, P_TEX_WIDTH, P_TEX_HEIGHT, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, particle_texture); // Upload floor texture glGenTextures(1, &floor_tex_id); glBindTexture(GL_TEXTURE_2D, floor_tex_id); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, F_TEX_WIDTH, F_TEX_HEIGHT, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, floor_texture); if (glfwExtensionSupported("GL_EXT_separate_specular_color")) { glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SEPARATE_SPECULAR_COLOR_EXT); } // Set filled polygon mode as default (not wireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); wireframe = 0; // Set initial times thread_sync.t = 0.0; thread_sync.dt = 0.001f; thread_sync.p_frame = 0; thread_sync.d_frame = 0; mtx_init(&thread_sync.particles_lock, mtx_timed); cnd_init(&thread_sync.p_done); cnd_init(&thread_sync.d_done); if (thrd_create(&physics_thread, physics_thread_main, window) != thrd_success) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetTime(0.0); while (!glfwWindowShouldClose(window)) { draw_scene(window, glfwGetTime()); glfwSwapBuffers(window); glfwPollEvents(); } thrd_join(physics_thread, NULL); glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main() { // glfw: initialize and configure // ------------------------------ glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_SAMPLES, 4); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X // glfw window creation // -------------------- GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); glfwMakeContextCurrent(window); if (window == NULL) { std::cout << "Failed to create GLFW window" << std::endl; glfwTerminate(); return -1; } glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // tell GLFW to capture our mouse glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // glad: load all OpenGL function pointers // --------------------------------------- if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { std::cout << "Failed to initialize GLAD" << std::endl; return -1; } // configure global opengl state // ----------------------------- glEnable(GL_DEPTH_TEST); // set depth function to less than AND equal for skybox depth trick. glDepthFunc(GL_LEQUAL); // enable seamless cubemap sampling for lower mip levels in the pre-filter map. glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // build and compile shaders // ------------------------- Shader pbrShader("2.2.2.pbr.vs", "2.2.2.pbr.fs"); Shader equirectangularToCubemapShader("2.2.2.cubemap.vs", "2.2.2.equirectangular_to_cubemap.fs"); Shader irradianceShader("2.2.2.cubemap.vs", "2.2.2.irradiance_convolution.fs"); Shader prefilterShader("2.2.2.cubemap.vs", "2.2.2.prefilter.fs"); Shader brdfShader("2.2.2.brdf.vs", "2.2.2.brdf.fs"); Shader backgroundShader("2.2.2.background.vs", "2.2.2.background.fs"); pbrShader.use(); pbrShader.setInt("irradianceMap", 0); pbrShader.setInt("prefilterMap", 1); pbrShader.setInt("brdfLUT", 2); pbrShader.setInt("albedoMap", 3); pbrShader.setInt("normalMap", 4); pbrShader.setInt("metallicMap", 5); pbrShader.setInt("roughnessMap", 6); pbrShader.setInt("aoMap", 7); backgroundShader.use(); backgroundShader.setInt("environmentMap", 0); // load PBR material textures // -------------------------- // rusted iron unsigned int ironAlbedoMap = loadTexture(FileSystem::getPath("resources/textures/pbr/rusted_iron/albedo.png").c_str()); unsigned int ironNormalMap = loadTexture(FileSystem::getPath("resources/textures/pbr/rusted_iron/normal.png").c_str()); unsigned int ironMetallicMap = loadTexture(FileSystem::getPath("resources/textures/pbr/rusted_iron/metallic.png").c_str()); unsigned int ironRoughnessMap = loadTexture(FileSystem::getPath("resources/textures/pbr/rusted_iron/roughness.png").c_str()); unsigned int ironAOMap = loadTexture(FileSystem::getPath("resources/textures/pbr/rusted_iron/ao.png").c_str()); // gold unsigned int goldAlbedoMap = loadTexture(FileSystem::getPath("resources/textures/pbr/gold/albedo.png").c_str()); unsigned int goldNormalMap = loadTexture(FileSystem::getPath("resources/textures/pbr/gold/normal.png").c_str()); unsigned int goldMetallicMap = loadTexture(FileSystem::getPath("resources/textures/pbr/gold/metallic.png").c_str()); unsigned int goldRoughnessMap = loadTexture(FileSystem::getPath("resources/textures/pbr/gold/roughness.png").c_str()); unsigned int goldAOMap = loadTexture(FileSystem::getPath("resources/textures/pbr/gold/ao.png").c_str()); // grass unsigned int grassAlbedoMap = loadTexture(FileSystem::getPath("resources/textures/pbr/grass/albedo.png").c_str()); unsigned int grassNormalMap = loadTexture(FileSystem::getPath("resources/textures/pbr/grass/normal.png").c_str()); unsigned int grassMetallicMap = loadTexture(FileSystem::getPath("resources/textures/pbr/grass/metallic.png").c_str()); unsigned int grassRoughnessMap = loadTexture(FileSystem::getPath("resources/textures/pbr/grass/roughness.png").c_str()); unsigned int grassAOMap = loadTexture(FileSystem::getPath("resources/textures/pbr/grass/ao.png").c_str()); // plastic unsigned int plasticAlbedoMap = loadTexture(FileSystem::getPath("resources/textures/pbr/plastic/albedo.png").c_str()); unsigned int plasticNormalMap = loadTexture(FileSystem::getPath("resources/textures/pbr/plastic/normal.png").c_str()); unsigned int plasticMetallicMap = loadTexture(FileSystem::getPath("resources/textures/pbr/plastic/metallic.png").c_str()); unsigned int plasticRoughnessMap = loadTexture(FileSystem::getPath("resources/textures/pbr/plastic/roughness.png").c_str()); unsigned int plasticAOMap = loadTexture(FileSystem::getPath("resources/textures/pbr/plastic/ao.png").c_str()); // wall unsigned int wallAlbedoMap = loadTexture(FileSystem::getPath("resources/textures/pbr/wall/albedo.png").c_str()); unsigned int wallNormalMap = loadTexture(FileSystem::getPath("resources/textures/pbr/wall/normal.png").c_str()); unsigned int wallMetallicMap = loadTexture(FileSystem::getPath("resources/textures/pbr/wall/metallic.png").c_str()); unsigned int wallRoughnessMap = loadTexture(FileSystem::getPath("resources/textures/pbr/wall/roughness.png").c_str()); unsigned int wallAOMap = loadTexture(FileSystem::getPath("resources/textures/pbr/wall/ao.png").c_str()); // lights // ------ glm::vec3 lightPositions[] = { glm::vec3(-10.0f, 10.0f, 10.0f), glm::vec3( 10.0f, 10.0f, 10.0f), glm::vec3(-10.0f, -10.0f, 10.0f), glm::vec3( 10.0f, -10.0f, 10.0f), }; glm::vec3 lightColors[] = { glm::vec3(300.0f, 300.0f, 300.0f), glm::vec3(300.0f, 300.0f, 300.0f), glm::vec3(300.0f, 300.0f, 300.0f), glm::vec3(300.0f, 300.0f, 300.0f) }; int nrRows = 7; int nrColumns = 7; float spacing = 2.5; // pbr: setup framebuffer // ---------------------- unsigned int captureFBO; unsigned int captureRBO; glGenFramebuffers(1, &captureFBO); glGenRenderbuffers(1, &captureRBO); glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRBO); // pbr: load the HDR environment map // --------------------------------- stbi_set_flip_vertically_on_load(true); int width, height, nrComponents; float *data = stbi_loadf(FileSystem::getPath("resources/textures/hdr/newport_loft.hdr").c_str(), &width, &height, &nrComponents, 0); unsigned int hdrTexture; if (data) { glGenTextures(1, &hdrTexture); glBindTexture(GL_TEXTURE_2D, hdrTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, data); // note how we specify the texture's data value to be float glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); stbi_image_free(data); } else { std::cout << "Failed to load HDR image." << std::endl; } // pbr: setup cubemap to render to and attach to framebuffer // --------------------------------------------------------- unsigned int envCubemap; glGenTextures(1, &envCubemap); glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); for (unsigned int i = 0; i < 6; ++i) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 512, 512, 0, GL_RGB, GL_FLOAT, nullptr); } glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // enable pre-filter mipmap sampling (combatting visible dots artifact) glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // pbr: set up projection and view matrices for capturing data onto the 6 cubemap face directions // ---------------------------------------------------------------------------------------------- glm::mat4 captureProjection = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f); glm::mat4 captureViews[] = { glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3( 1.0f, 0.0f, 0.0f), glm::vec3(0.0f, -1.0f, 0.0f)), glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(0.0f, -1.0f, 0.0f)), glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3( 0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)), glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3( 0.0f, -1.0f, 0.0f), glm::vec3(0.0f, 0.0f, -1.0f)), glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3( 0.0f, 0.0f, 1.0f), glm::vec3(0.0f, -1.0f, 0.0f)), glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3( 0.0f, 0.0f, -1.0f), glm::vec3(0.0f, -1.0f, 0.0f)) }; // pbr: convert HDR equirectangular environment map to cubemap equivalent // ---------------------------------------------------------------------- equirectangularToCubemapShader.use(); equirectangularToCubemapShader.setInt("equirectangularMap", 0); equirectangularToCubemapShader.setMat4("projection", captureProjection); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, hdrTexture); glViewport(0, 0, 512, 512); // don't forget to configure the viewport to the capture dimensions. glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); for (unsigned int i = 0; i < 6; ++i) { equirectangularToCubemapShader.setMat4("view", captureViews[i]); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, envCubemap, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderCube(); } glBindFramebuffer(GL_FRAMEBUFFER, 0); // then let OpenGL generate mipmaps from first mip face (combatting visible dots artifact) glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glGenerateMipmap(GL_TEXTURE_CUBE_MAP); // pbr: create an irradiance cubemap, and re-scale capture FBO to irradiance scale. // -------------------------------------------------------------------------------- unsigned int irradianceMap; glGenTextures(1, &irradianceMap); glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap); for (unsigned int i = 0; i < 6; ++i) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 32, 32, 0, GL_RGB, GL_FLOAT, nullptr); } glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 32, 32); // pbr: solve diffuse integral by convolution to create an irradiance (cube)map. // ----------------------------------------------------------------------------- irradianceShader.use(); irradianceShader.setInt("environmentMap", 0); irradianceShader.setMat4("projection", captureProjection); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glViewport(0, 0, 32, 32); // don't forget to configure the viewport to the capture dimensions. glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); for (unsigned int i = 0; i < 6; ++i) { irradianceShader.setMat4("view", captureViews[i]); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, irradianceMap, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderCube(); } glBindFramebuffer(GL_FRAMEBUFFER, 0); // pbr: create a pre-filter cubemap, and re-scale capture FBO to pre-filter scale. // -------------------------------------------------------------------------------- unsigned int prefilterMap; glGenTextures(1, &prefilterMap); glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap); for (unsigned int i = 0; i < 6; ++i) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 128, 128, 0, GL_RGB, GL_FLOAT, nullptr); } glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // be sure to set minifcation filter to mip_linear glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // generate mipmaps for the cubemap so OpenGL automatically allocates the required memory. glGenerateMipmap(GL_TEXTURE_CUBE_MAP); // pbr: run a quasi monte-carlo simulation on the environment lighting to create a prefilter (cube)map. // ---------------------------------------------------------------------------------------------------- prefilterShader.use(); prefilterShader.setInt("environmentMap", 0); prefilterShader.setMat4("projection", captureProjection); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); unsigned int maxMipLevels = 5; for (unsigned int mip = 0; mip < maxMipLevels; ++mip) { // reisze framebuffer according to mip-level size. unsigned int mipWidth = 128 * std::pow(0.5, mip); unsigned int mipHeight = 128 * std::pow(0.5, mip); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, mipWidth, mipHeight); glViewport(0, 0, mipWidth, mipHeight); float roughness = (float)mip / (float)(maxMipLevels - 1); prefilterShader.setFloat("roughness", roughness); for (unsigned int i = 0; i < 6; ++i) { prefilterShader.setMat4("view", captureViews[i]); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, prefilterMap, mip); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderCube(); } } glBindFramebuffer(GL_FRAMEBUFFER, 0); // pbr: generate a 2D LUT from the BRDF equations used. // ---------------------------------------------------- unsigned int brdfLUTTexture; glGenTextures(1, &brdfLUTTexture); // pre-allocate enough memory for the LUT texture. glBindTexture(GL_TEXTURE_2D, brdfLUTTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, 512, 512, 0, GL_RG, GL_FLOAT, 0); // be sure to set wrapping mode to GL_CLAMP_TO_EDGE glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // then re-configure capture framebuffer object and render screen-space quad with BRDF shader. glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, brdfLUTTexture, 0); glViewport(0, 0, 512, 512); brdfShader.use(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderQuad(); glBindFramebuffer(GL_FRAMEBUFFER, 0); // initialize static shader uniforms before rendering // -------------------------------------------------- glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); pbrShader.use(); pbrShader.setMat4("projection", projection); backgroundShader.use(); backgroundShader.setMat4("projection", projection); // then before rendering, configure the viewport to the original framebuffer's screen dimensions int scrWidth, scrHeight; glfwGetFramebufferSize(window, &scrWidth, &scrHeight); glViewport(0, 0, scrWidth, scrHeight); // render loop // ----------- while (!glfwWindowShouldClose(window)) { // per-frame time logic // -------------------- float currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // input // ----- processInput(window); // render // ------ glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // render scene, supplying the convoluted irradiance map to the final shader. // ------------------------------------------------------------------------------------------ pbrShader.use(); glm::mat4 model; glm::mat4 view = camera.GetViewMatrix(); pbrShader.setMat4("view", view); pbrShader.setVec3("camPos", camera.Position); // bind pre-computed IBL data glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, brdfLUTTexture); // rusted iron glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, ironAlbedoMap); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, ironNormalMap); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, ironMetallicMap); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, ironRoughnessMap); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, ironAOMap); model = glm::mat4(); model = glm::translate(model, glm::vec3(-5.0, 0.0, 2.0)); pbrShader.setMat4("model", model); renderSphere(); // gold glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, goldAlbedoMap); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, goldNormalMap); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, goldMetallicMap); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, goldRoughnessMap); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, goldAOMap); model = glm::mat4(); model = glm::translate(model, glm::vec3(-3.0, 0.0, 2.0)); pbrShader.setMat4("model", model); renderSphere(); // grass glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, grassAlbedoMap); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, grassNormalMap); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, grassMetallicMap); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, grassRoughnessMap); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, grassAOMap); model = glm::mat4(); model = glm::translate(model, glm::vec3(-1.0, 0.0, 2.0)); pbrShader.setMat4("model", model); renderSphere(); // plastic glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, plasticAlbedoMap); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, plasticNormalMap); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, plasticMetallicMap); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, plasticRoughnessMap); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, plasticAOMap); model = glm::mat4(); model = glm::translate(model, glm::vec3(1.0, 0.0, 2.0)); pbrShader.setMat4("model", model); renderSphere(); // wall glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, wallAlbedoMap); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, wallNormalMap); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, wallMetallicMap); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, wallRoughnessMap); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, wallAOMap); model = glm::mat4(); model = glm::translate(model, glm::vec3(3.0, 0.0, 2.0)); pbrShader.setMat4("model", model); renderSphere(); // render light source (simply re-render sphere at light positions) // this looks a bit off as we use the same shader, but it'll make their positions obvious and // keeps the codeprint small. for (unsigned int i = 0; i < sizeof(lightPositions) / sizeof(lightPositions[0]); ++i) { glm::vec3 newPos = lightPositions[i] + glm::vec3(sin(glfwGetTime() * 5.0) * 5.0, 0.0, 0.0); newPos = lightPositions[i]; pbrShader.setVec3("lightPositions[" + std::to_string(i) + "]", newPos); pbrShader.setVec3("lightColors[" + std::to_string(i) + "]", lightColors[i]); model = glm::mat4(); model = glm::translate(model, newPos); model = glm::scale(model, glm::vec3(0.5f)); pbrShader.setMat4("model", model); renderSphere(); } // render skybox (render as last to prevent overdraw) backgroundShader.use(); backgroundShader.setMat4("view", view); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); //glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap); // display irradiance map //glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap); // display prefilter map renderCube(); // render BRDF map to screen //brdfShader.Use(); //renderQuad(); // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.) // ------------------------------------------------------------------------------- glfwSwapBuffers(window); glfwPollEvents(); } // glfw: terminate, clearing all previously allocated GLFW resources. // ------------------------------------------------------------------ glfwTerminate(); return 0; }
int main(int argc, char* argv[]) { GLFWwindow* window; MarkerTracker markerTracker; /* Initialize the library */ if (!glfwInit()) return -1; // initialize the window system /* Create a windowed mode window and its OpenGL context */ window = glfwCreateWindow(camera_width, camera_height, "Combine", NULL, NULL); if (!window) { glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glfwSwapInterval(1); int window_width, window_height; glfwGetFramebufferSize(window, &window_width, &window_height); glViewport(0, 0, window_width, window_height); // initialize the GL library initGL(argc, argv); // setup OpenCV cv::Mat img_bgr; cv::VideoCapture cap; cap.set(CV_CAP_PROP_FRAME_WIDTH, camera_width); cap.set(CV_CAP_PROP_FRAME_HEIGHT, camera_height); initVideoStream(cap); /* Loop until the user closes the window */ while (!glfwWindowShouldClose(window)) { cap >> img_bgr; if (img_bgr.empty()){ std::cout << "Could not query frame. Trying to reinitialize." << std::endl; initVideoStream(cap); cv::waitKey(1000); // Wait for one sec. continue; } // Track markers markerTracker.find(img_bgr); /* Render here */ display(window, img_bgr); /* Swap front and back buffers */ glfwSwapBuffers(window); /* Poll for and process events */ glfwPollEvents(); } glfwTerminate(); return 0; }
int main(void) { int i; GLFWwindow* window; GLFWcursor* star_cursors[CURSOR_FRAME_COUNT]; GLFWcursor* current_frame = NULL; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); for (i = 0; i < CURSOR_FRAME_COUNT; i++) { star_cursors[i] = create_cursor_frame(i / (float) CURSOR_FRAME_COUNT); if (!star_cursors[i]) { glfwTerminate(); exit(EXIT_FAILURE); } } for (i = 0; i < sizeof(standard_cursors) / sizeof(standard_cursors[0]); i++) { const int shapes[] = { GLFW_ARROW_CURSOR, GLFW_IBEAM_CURSOR, GLFW_CROSSHAIR_CURSOR, GLFW_HAND_CURSOR, GLFW_HRESIZE_CURSOR, GLFW_VRESIZE_CURSOR }; standard_cursors[i] = glfwCreateStandardCursor(shapes[i]); if (!standard_cursors[i]) { glfwTerminate(); exit(EXIT_FAILURE); } } window = glfwCreateWindow(640, 480, "Cursor Test", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwGetCursorPos(window, &cursor_x, &cursor_y); printf("Cursor position: %f %f\n", cursor_x, cursor_y); glfwSetCursorPosCallback(window, cursor_position_callback); glfwSetKeyCallback(window, key_callback); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT); if (track_cursor) { int wnd_width, wnd_height, fb_width, fb_height; float scale; glfwGetWindowSize(window, &wnd_width, &wnd_height); glfwGetFramebufferSize(window, &fb_width, &fb_height); scale = (float) fb_width / (float) wnd_width; glViewport(0, 0, fb_width, fb_height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.f, fb_width, 0.f, fb_height, 0.f, 1.f); glBegin(GL_LINES); glVertex2f(0.f, (GLfloat) (fb_height - cursor_y * scale)); glVertex2f((GLfloat) fb_width, (GLfloat) (fb_height - cursor_y * scale)); glVertex2f((GLfloat) cursor_x * scale, 0.f); glVertex2f((GLfloat) cursor_x * scale, (GLfloat) fb_height); glEnd(); } glfwSwapBuffers(window); if (animate_cursor) { const int i = (int) (glfwGetTime() * 30.0) % CURSOR_FRAME_COUNT; if (current_frame != star_cursors[i]) { glfwSetCursor(window, star_cursors[i]); current_frame = star_cursors[i]; } } else current_frame = NULL; if (wait_events) { if (animate_cursor) glfwWaitEventsTimeout(1.0 / 30.0); else glfwWaitEvents(); } else glfwPollEvents(); // Workaround for an issue with msvcrt and mintty fflush(stdout); } glfwDestroyWindow(window); for (i = 0; i < CURSOR_FRAME_COUNT; i++) glfwDestroyCursor(star_cursors[i]); for (i = 0; i < sizeof(standard_cursors) / sizeof(standard_cursors[0]); i++) glfwDestroyCursor(standard_cursors[i]); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { //Initialize GLFW GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); #ifdef WIN32 //Initialize GLEW glewExperimental = GL_TRUE; GLenum glewInitStatus = glewInit(); if (glewInitStatus != GLEW_OK) { TRACE("Glew Init Error: " << glewGetErrorString(glewInitStatus)); glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_FAILURE); } #endif Rocket::Core::Context* context = nullptr; glClearColor(0.0f, 0.0f, 0.4f, 0.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); g_game.Initialize(); // Set up transformation matrices glm::mat4 Projection; glm::mat4 View; glm::mat4 ViewProjection; //Main loop std::chrono::duration<double> t(0.0); std::chrono::duration<double> dt(0.01); std::chrono::duration<double> accumulator(0.0); std::chrono::time_point<std::chrono::system_clock> currentTime, newTime; currentTime = std::chrono::system_clock::now(); while (!glfwWindowShouldClose(window)) { newTime = std::chrono::system_clock::now(); std::chrono::duration<double> elapsed_seconds = newTime - currentTime; currentTime = newTime; accumulator += elapsed_seconds; //Simulation while (accumulator >= dt) { g_game.SimulationStep((float)dt.count()); accumulator -= dt; t += dt; } //Render { //If user has resized window, update viewport and projection int width, height; glfwGetFramebufferSize(window, &width, &height); //Draw glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); g_game.Render(width, height); glfwSwapBuffers(window); glfwPollEvents(); } } //Main loop has exited, clean up glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main (int argc, char *argv[]) { progname=argv[0]; //! The pointer to the GLFW window GLFWwindow* window; //! Setting up the GLFW Error callback glfwSetErrorCallback(csX75::error_callback); //! Initialize GLFW if (!glfwInit()) return -1; setup(argc, argv); int win_width=512; int win_height=512; //! Create a windowed mode window and its OpenGL context window = glfwCreateWindow(win_width, win_height, "ToyLOGO", NULL, NULL); if (!window) { glfwTerminate(); return -1; } //! Make the window's context current glfwMakeContextCurrent(window); //Keyboard Callback glfwSetKeyCallback(window, csX75::key_callback); //Framebuffer resize callback glfwSetFramebufferSizeCallback(window, csX75::framebuffer_size_callback); // Ensure we can capture the escape key being pressed below glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE); glfwGetFramebufferSize(window, &win_width, &win_height); csX75::framebuffer_size_callback(window, win_width, win_height); //Initialize GL state csX75::initGL(); glEnable(GL_DEPTH_TEST); // Loop until the user closes the window while (glfwWindowShouldClose(window) == 0) { // Render here renderGL(window); // Swap front and back buffers glfwSwapBuffers(window); // Poll for and process events glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); return 0; }
int main(int argc, char **argv) #endif { const GLFWvidmode *video_mode; int c; while ((c = fz_getopt(argc, argv, "p:r:W:H:S:U:X")) != -1) { switch (c) { default: usage(argv[0]); break; case 'p': password = fz_optarg; break; case 'r': currentzoom = fz_atof(fz_optarg); break; case 'W': layout_w = fz_atof(fz_optarg); break; case 'H': layout_h = fz_atof(fz_optarg); break; case 'S': layout_em = fz_atof(fz_optarg); break; case 'U': layout_css = fz_optarg; break; case 'X': layout_use_doc_css = 0; break; } } if (fz_optind < argc) { fz_strlcpy(filename, argv[fz_optind], sizeof filename); } else { #ifdef _WIN32 win_install(); if (!win_open_file(filename, sizeof filename)) exit(0); #else usage(argv[0]); #endif } title = strrchr(filename, '/'); if (!title) title = strrchr(filename, '\\'); if (title) ++title; else title = filename; memset(&ui, 0, sizeof ui); search_input.p = search_input.text; search_input.q = search_input.p; search_input.end = search_input.p; glfwSetErrorCallback(on_error); if (!glfwInit()) { fprintf(stderr, "cannot initialize glfw\n"); exit(1); } video_mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); screen_w = video_mode->width; screen_h = video_mode->height; window = glfwCreateWindow(DEFAULT_WINDOW_W, DEFAULT_WINDOW_H, filename, NULL, NULL); if (!window) { fprintf(stderr, "cannot create glfw window\n"); exit(1); } glfwMakeContextCurrent(window); ctx = fz_new_context(NULL, NULL, 0); fz_register_document_handlers(ctx); if (layout_css) { fz_buffer *buf = fz_read_file(ctx, layout_css); fz_set_user_css(ctx, fz_string_from_buffer(ctx, buf)); fz_drop_buffer(ctx, buf); } fz_set_use_document_css(ctx, layout_use_doc_css); has_ARB_texture_non_power_of_two = glfwExtensionSupported("GL_ARB_texture_non_power_of_two"); if (!has_ARB_texture_non_power_of_two) fz_warn(ctx, "OpenGL implementation does not support non-power of two texture sizes"); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); ui.fontsize = DEFAULT_UI_FONTSIZE; ui.baseline = DEFAULT_UI_BASELINE; ui.lineheight = DEFAULT_UI_LINEHEIGHT; ui_init_fonts(ctx, ui.fontsize); reload(); shrinkwrap(); glfwSetFramebufferSizeCallback(window, on_reshape); glfwSetCursorPosCallback(window, on_mouse_motion); glfwSetMouseButtonCallback(window, on_mouse_button); glfwSetScrollCallback(window, on_scroll); glfwSetCharModsCallback(window, on_char); glfwSetKeyCallback(window, on_key); glfwSetWindowRefreshCallback(window, on_display); glfwGetFramebufferSize(window, &window_w, &window_h); ui_needs_update = 1; while (!glfwWindowShouldClose(window)) { glfwWaitEvents(); if (ui_needs_update) run_main_loop(); } ui_finish_fonts(ctx); fz_drop_link(ctx, links); fz_drop_page(ctx, page); fz_drop_outline(ctx, outline); fz_drop_document(ctx, doc); fz_drop_context(ctx); glfwTerminate(); return 0; }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", nullptr, nullptr); if (window == nullptr) { std::cout << "Failed to create GLFW window" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, keyCallback); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cout << "Failed to initialize GLEW" << std::endl; return -1; } int framebufferWidth, framebufferHeight; glfwGetFramebufferSize(window, &framebufferWidth, &framebufferHeight); glViewport(0, 0, framebufferWidth, framebufferHeight); Shader ourShader("/Users/sgarcia/Code/C++/opengl/textures/shader.vs", "/Users/sgarcia/Code/C++/opengl/textures/shader.frag"); GLuint vertexArrayObject, vertexBufferObject, elementBufferObject; GLfloat vertices[] = { // Positions // Colors // Texture Coords 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // Top Right 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // Bottom Right -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // Bottom Left -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // Top Left }; GLuint indices[] = { 0, 1, 3, // First Triangle 1, 2, 3 // Second Triangle }; glGenVertexArrays(1, &vertexArrayObject); glGenBuffers(1, &vertexBufferObject); glGenBuffers(1, &elementBufferObject); // Bind Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). glBindVertexArray(vertexArrayObject); // Copy triangleVertices array in a buffer for OpenGL to use glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // Indices for elements glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBufferObject); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); // Position Attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Position coordinates glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); // Color values glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); // Texture coordinates glEnableVertexAttribArray(2); // Unbind array and element buffers glBindBuffer(GL_ARRAY_BUFFER, 0); // Unbind the Vertex Array Object; glBindVertexArray(0); // Load texture GLuint texture1, texture2; glGenTextures(2, &texture1); glGenTextures(1, &texture2); glBindTexture(GL_TEXTURE_2D, texture1); // Set texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load and generate texture int width, height; unsigned char *image = SOIL_load_image("/Users/sgarcia/Code/C++/opengl/asset/container.jpg", &width, &height, 0, SOIL_LOAD_RGB); if (image == nullptr) { std::cout << "Failed to load texture image." << std::endl; return -1; } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); // Unbind texture glBindTexture(GL_TEXTURE_2D, texture2); // Set texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load and generate texture image = SOIL_load_image("/Users/sgarcia/Code/C++/opengl/asset/awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB); if (image == nullptr) { std::cout << "Failed to load texture image." << std::endl; return -1; } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); ourShader.Use(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture1); glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture2"), 1); glBindVertexArray(vertexArrayObject); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glBindTexture(GL_TEXTURE_2D, 0); glfwSwapBuffers(window); } glDeleteVertexArrays(1, &vertexArrayObject); glDeleteBuffers(1, &vertexBufferObject); glDeleteBuffers(1, &elementBufferObject); glfwTerminate(); return 0; }
void InitImGui() { int w, h; int fb_w, fb_h; glfwGetWindowSize(window, &w, &h); glfwGetFramebufferSize(window, &fb_w, &fb_h); mousePosScale.x = (float)fb_w / w; // Some screens e.g. Retina display have framebuffer size != from window size, and mouse inputs are given in window/screen coordinates. mousePosScale.y = (float)fb_h / h; ImGuiIO& io = ImGui::GetIO(); io.DisplaySize = ImVec2((float)fb_w, (float)fb_h); // Display size, in pixels. For clamping windows positions. io.DeltaTime = 1.0f/60.0f; // Time elapsed since last frame, in seconds (in this sample app we'll override this every frame because our timestep is variable) io.PixelCenterOffset = 0.0f; // Align OpenGL texels io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB; // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array. io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT; io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT; io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP; io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN; io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME; io.KeyMap[ImGuiKey_End] = GLFW_KEY_END; io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE; io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE; io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER; io.KeyMap[ImGuiKey_Escape] = GLFW_KEY_ESCAPE; io.KeyMap[ImGuiKey_A] = GLFW_KEY_A; io.KeyMap[ImGuiKey_C] = GLFW_KEY_C; io.KeyMap[ImGuiKey_V] = GLFW_KEY_V; io.KeyMap[ImGuiKey_X] = GLFW_KEY_X; io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y; io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z; io.RenderDrawListsFn = ImImpl_RenderDrawLists; io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; #ifdef _MSC_VER io.ImeSetInputScreenPosFn = ImImpl_ImeSetInputScreenPosFn; #endif // Load font texture glGenTextures(1, &fontTex); glBindTexture(GL_TEXTURE_2D, fontTex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); #if 1 // Default font (embedded in code) const void* png_data; unsigned int png_size; ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size); int tex_x, tex_y, tex_comp; void* tex_data = stbi_load_from_memory((const unsigned char*)png_data, (int)png_size, &tex_x, &tex_y, &tex_comp, 0); IM_ASSERT(tex_data != NULL); #else // Custom font from filesystem io.Font = new ImBitmapFont(); io.Font->LoadFromFile("../../extra_fonts/mplus-2m-medium_18.fnt"); IM_ASSERT(io.Font->IsLoaded()); int tex_x, tex_y, tex_comp; void* tex_data = stbi_load("../../extra_fonts/mplus-2m-medium_18.png", &tex_x, &tex_y, &tex_comp, 0); IM_ASSERT(tex_data != NULL); // Automatically find white pixel from the texture we just loaded // (io.FontTexUvForWhite needs to contains UV coordinates pointing to a white pixel in order to render solid objects) for (int tex_data_off = 0; tex_data_off < tex_x*tex_y; tex_data_off++) if (((unsigned int*)tex_data)[tex_data_off] == 0xffffffff) { io.FontTexUvForWhite = ImVec2((float)(tex_data_off % tex_x)/(tex_x), (float)(tex_data_off / tex_x)/(tex_y)); break; } #endif glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_x, tex_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_data); stbi_image_free(tex_data); }
int main() { GLFWwindow* window; NVGcontext* vg = NULL; GPUtimer gpuTimer; PerfGraph fps, cpuGraph, gpuGraph; double prevt = 0, cpuTime = 0; NVGLUframebuffer* fb = NULL; int winWidth, winHeight; int fbWidth, fbHeight; float pxRatio; if (!glfwInit()) { printf("Failed to init GLFW."); return -1; } initGraph(&fps, GRAPH_RENDER_FPS, "Frame Time"); initGraph(&cpuGraph, GRAPH_RENDER_MS, "CPU Time"); initGraph(&gpuGraph, GRAPH_RENDER_MS, "GPU Time"); glfwSetErrorCallback(errorcb); #ifndef _WIN32 // don't require this on win32, and works with more cards glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); #endif glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1); #ifdef DEMO_MSAA glfwWindowHint(GLFW_SAMPLES, 4); #endif window = glfwCreateWindow(1000, 600, "NanoVG", NULL, NULL); // window = glfwCreateWindow(1000, 600, "NanoVG", glfwGetPrimaryMonitor(), NULL); if (!window) { glfwTerminate(); return -1; } glfwSetKeyCallback(window, key); glfwMakeContextCurrent(window); #ifdef NANOVG_GLEW glewExperimental = GL_TRUE; if(glewInit() != GLEW_OK) { printf("Could not init glew.\n"); return -1; } // GLEW generates GL error because it calls glGetString(GL_EXTENSIONS), we'll consume it here. glGetError(); #endif #ifdef DEMO_MSAA vg = nvgCreateGL3(NVG_STENCIL_STROKES | NVG_DEBUG); #else vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES | NVG_DEBUG); #endif if (vg == NULL) { printf("Could not init nanovg.\n"); return -1; } // Create hi-dpi FBO for hi-dpi screens. glfwGetWindowSize(window, &winWidth, &winHeight); glfwGetFramebufferSize(window, &fbWidth, &fbHeight); // Calculate pixel ration for hi-dpi devices. pxRatio = (float)fbWidth / (float)winWidth; // The image pattern is tiled, set repeat on x and y. fb = nvgluCreateFramebuffer(vg, (int)(100*pxRatio), (int)(100*pxRatio), NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY); if (fb == NULL) { printf("Could not create FBO.\n"); return -1; } if (loadFonts(vg) == -1) { printf("Could not load fonts\n"); return -1; } glfwSwapInterval(0); initGPUTimer(&gpuTimer); glfwSetTime(0); prevt = glfwGetTime(); while (!glfwWindowShouldClose(window)) { double mx, my, t, dt; float gpuTimes[3]; int i, n; t = glfwGetTime(); dt = t - prevt; prevt = t; startGPUTimer(&gpuTimer); glfwGetCursorPos(window, &mx, &my); glfwGetWindowSize(window, &winWidth, &winHeight); glfwGetFramebufferSize(window, &fbWidth, &fbHeight); // Calculate pixel ration for hi-dpi devices. pxRatio = (float)fbWidth / (float)winWidth; renderPattern(vg, fb, t, pxRatio); // Update and render glViewport(0, 0, fbWidth, fbHeight); glClearColor(0.3f, 0.3f, 0.32f, 1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); nvgBeginFrame(vg, winWidth, winHeight, pxRatio); // Use the FBO as image pattern. if (fb != NULL) { NVGpaint img = nvgImagePattern(vg, 0, 0, 100, 100, 0, fb->image, 1.0f); nvgSave(vg); for (i = 0; i < 20; i++) { nvgBeginPath(vg); nvgRect(vg, 10 + i*30,10, 10, winHeight-20); nvgFillColor(vg, nvgHSLA(i/19.0f, 0.5f, 0.5f, 255)); nvgFill(vg); } nvgBeginPath(vg); nvgRoundedRect(vg, 140 + sinf(t*1.3f)*100, 140 + cosf(t*1.71244f)*100, 250, 250, 20); nvgFillPaint(vg, img); nvgFill(vg); nvgStrokeColor(vg, nvgRGBA(220,160,0,255)); nvgStrokeWidth(vg, 3.0f); nvgStroke(vg); nvgRestore(vg); } renderGraph(vg, 5,5, &fps); renderGraph(vg, 5+200+5,5, &cpuGraph); if (gpuTimer.supported) renderGraph(vg, 5+200+5+200+5,5, &gpuGraph); nvgEndFrame(vg); // Measure the CPU time taken excluding swap buffers (as the swap may wait for GPU) cpuTime = glfwGetTime() - t; updateGraph(&fps, dt); updateGraph(&cpuGraph, cpuTime); // We may get multiple results. n = stopGPUTimer(&gpuTimer, gpuTimes, 3); for (i = 0; i < n; i++) updateGraph(&gpuGraph, gpuTimes[i]); glfwSwapBuffers(window); glfwPollEvents(); } nvgluDeleteFramebuffer(fb); nvgDeleteGL3(vg); printf("Average Frame Time: %.2f ms\n", getGraphAverage(&fps) * 1000.0f); printf(" CPU Time: %.2f ms\n", getGraphAverage(&cpuGraph) * 1000.0f); printf(" GPU Time: %.2f ms\n", getGraphAverage(&gpuGraph) * 1000.0f); glfwTerminate(); return 0; }
int guigl_main(duc *duc, int argc, char *argv[]) { char *path = "."; if(argc > 0) path = argv[0]; fuzz = opt_fuzz; if(opt_palette) { char c = tolower(opt_palette[0]); if(c == 's') palette = DUC_GRAPH_PALETTE_SIZE; if(c == 'r') palette = DUC_GRAPH_PALETTE_RAINBOW; if(c == 'g') palette = DUC_GRAPH_PALETTE_GREYSCALE; if(c == 'm') palette = DUC_GRAPH_PALETTE_MONOCHROME; if(c == 'c') palette = DUC_GRAPH_PALETTE_CLASSIC; } int r = duc_open(duc, opt_database, DUC_OPEN_RO); if(r != DUC_OK) { duc_log(duc, DUC_LOG_FTL, "%s", duc_strerror(duc)); return -1; } dir = duc_dir_open(duc, path); if(dir == NULL) { duc_log(duc, DUC_LOG_FTL, "%s", duc_strerror(duc)); return -1; } if(!glfwInit()) { duc_log(duc, DUC_LOG_FTL, "Error initializen glfw"); return -1; } glfwWindowHint(GLFW_SAMPLES, 4); GLFWwindow* window = window = glfwCreateWindow(640, 480, "Duc", NULL, NULL);; if(window == NULL) { duc_log(duc, DUC_LOG_FTL, "Error creating glfw window"); glfwTerminate(); return -1; } glfwMakeContextCurrent(window); gladLoadGLES2Loader((GLADloadproc) glfwGetProcAddress); glfwGetFramebufferSize(window, &win_w, &win_h); double font_scale = 1.0; sc2fb(window, &font_scale, NULL); graph = duc_graph_new_opengl(duc, font_scale); glfwSetKeyCallback(window, cb_keyboard); glfwSetFramebufferSizeCallback(window, cb_winsize); glfwSetMouseButtonCallback(window, cb_mouse_button); glfwSetCursorPosCallback(window, cb_mouse_motion); glfwSetScrollCallback(window, cb_scroll); while (!glfwWindowShouldClose(window)) { draw(window); glfwWaitEvents(); } glfwTerminate(); return 0; }
int Window::getWidth() const { int width; glfwGetFramebufferSize(handle, &width, nullptr); return width; }