revisit sparsetexture example

Author: cgcostume

source/examples/shaderincludes/main.cpp

@@ -56,6 +56,8 @@ void deinitialize()
 void draw()
 {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glViewport(0, 0, g_size.x, g_size.y);
     g_quad->draw();
 }
 

source/examples/sparsetexture/CMakeLists.txt

@@ -29,8 +29,11 @@ message(STATUS "Example ${target}")
 
 set(sources
     main.cpp
+    
     ScreenAlignedQuad.h
     ScreenAlignedQuad.cpp
+    contextinfo.inl
+    datapath.inl
 )
 
 
@@ -80,6 +83,7 @@ target_link_libraries(${target}
     ${DEFAULT_LIBRARIES}
     ${GLFW_LIBRARIES}
     ${META_PROJECT_NAME}::globjects
+    cpplocate::cpplocate
 )
 
 

source/examples/sparsetexture/contextinfo.inl

@@ -0,0 +1,16 @@
+
+#include <iostream>
+
+
+namespace common
+{
+
+    void printContextInfo()
+    {
+        std::cout << std::endl
+            << "OpenGL Version:  " << glbinding::ContextInfo::version() << std::endl
+            << "OpenGL Vendor:   " << glbinding::ContextInfo::vendor() << std::endl
+            << "OpenGL Renderer: " << glbinding::ContextInfo::renderer() << std::endl << std::endl;
+    }
+
+}

source/examples/sparsetexture/datapath.inl

@@ -0,0 +1,38 @@
+
+#include <string>
+
+#include <cpplocate/cpplocate.h>
+#include <cpplocate/ModuleInfo.h>
+
+
+namespace common
+{
+
+    std::string normalizePath(const std::string & filepath)
+    {
+        auto copy = filepath;
+        std::replace(copy.begin(), copy.end(), '\\', '/');
+
+        auto i = copy.find_last_of('/');
+        if (i == copy.size() - 1)
+            copy = copy.substr(0, copy.size() - 1);
+
+        return copy;
+    }
+
+    std::string retrieveDataPath(const std::string & module, const std::string & key)
+    {
+        const auto moduleInfo = cpplocate::findModule(module);
+
+        auto dataPath = moduleInfo.value(key);
+        dataPath = normalizePath(dataPath);
+
+        if (dataPath.empty())
+            dataPath = "data/";
+        else
+            dataPath += "/";
+
+        return dataPath;
+    }
+
+}

source/examples/sparsetexture/main.cpp

@@ -2,7 +2,8 @@
 #include <algorithm>
 #include <random>
 
-#include <glm/glm.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
 
 #include <glbinding/gl/gl.h>
 #include <glbinding/gl/extension.h>
@@ -19,136 +20,72 @@
 
 #include "ScreenAlignedQuad.h"
 
+// example commons
+#include "contextinfo.inl"
+#include "datapath.inl"
 
-using namespace gl;
-using namespace glm;
-using namespace globjects;
-
-
-namespace {
-    bool g_toggleFS = false;
-    bool g_isFS = false;
-
-    Texture * g_texture = nullptr;
-    ScreenAlignedQuad * g_quad = nullptr;
-    ivec2 g_pageSize;
-    ivec2 g_numPages;
-    int g_totalPages;
-
-    const ivec2 g_textureSize(4096);
-    const int g_maxResidentPages(512);
-}
-
-
-void key_callback(GLFWwindow * window, int key, int /*scancode*/, int action, int /*modes*/)
-{
-    if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
-        glfwSetWindowShouldClose(window, true);
 
-    if (key == GLFW_KEY_F5 && action == GLFW_RELEASE)
-        File::reloadAll();
+using namespace gl;
 
-    if (key == GLFW_KEY_F11 && action == GLFW_RELEASE)
-        g_toggleFS = true;
-}
 
-GLFWwindow * createWindow(bool fs = false)
+namespace 
 {
-    // Set GLFW window hints
-    glfwSetErrorCallback( [] (int /*error*/, const char * description) { puts(description); } );
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
-
-    // Create a context and, if valid, make it current
-    GLFWwindow * window = glfwCreateWindow(1024, 768, "", fs ? glfwGetPrimaryMonitor() : NULL, NULL);
-    if (window == nullptr)
-    {
-        critical() << "Context creation failed. Terminate execution.";
-
-        glfwTerminate();
-        exit(1);
-    }
-    glfwMakeContextCurrent(window);
-
-    // Create callback that when user presses ESC, the context should be destroyed and window closed
-    glfwSetKeyCallback(window, key_callback);
-
-    // Initialize globjects (internally initializes glbinding, and registers the current context)
-    globjects::init();
-
-    // Do only on startup
-    if (!g_toggleFS)
-    {
-       // Dump information about context and graphics card
-       info() << std::endl
-           << "OpenGL Version:  " << glbinding::ContextInfo::version() << std::endl
-           << "OpenGL Vendor:   " << glbinding::ContextInfo::vendor() << std::endl
-           << "OpenGL Renderer: " << glbinding::ContextInfo::renderer() << std::endl;
-    }
-
-    if (!hasExtension(GLextension::GL_ARB_sparse_texture))
-    {
-        critical() << "Sparse textues not supported.";
+    globjects::Texture * g_texture = nullptr;
+    ScreenAlignedQuad * g_quad = nullptr;
 
-        glfwTerminate();
-        exit(1);
-    }
+    auto g_pageSize = glm::ivec2{ };
+    auto g_numPages = glm::ivec2{ };
+    auto g_totalPages = 0u;
 
-    glClearColor(0.2f, 0.3f, 0.4f, 1.f);
+    const auto g_textureSize = glm::ivec2{4096};
+    const auto g_maxResidentPages = 512;
 
-    g_isFS = fs;
-    return window;
+    auto g_size = glm::ivec2{};
 }
 
-void destroyWindow(GLFWwindow * window)
-{
-    globjects::detachAllObjects();
-    glfwDestroyWindow(window);
-}
 
 void initialize()
 {
     // Initialize OpenGL objects
     int numPageSizes;
     glGetInternalformativ(GL_TEXTURE_2D, GL_RGBA8, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, sizeof(int), &numPageSizes);
-    info("GL_NUM_VIRTUAL_PAGE_SIZES_ARB = %d;", numPageSizes);
+    globjects::info("GL_NUM_VIRTUAL_PAGE_SIZES_ARB = %d;", numPageSizes);
 
     if (numPageSizes == 0) 
     {
-        fatal("Sparse Texture not supported for GL_RGBA8");
+        globjects::fatal("Sparse Texture not supported for GL_RGBA8");
         exit(1);
     }
 
     std::vector<int> pageSizesX(numPageSizes);
     glGetInternalformativ(GL_TEXTURE_2D, GL_RGBA8, GL_VIRTUAL_PAGE_SIZE_X_ARB
         , static_cast<GLsizei>(numPageSizes * sizeof(int)), pageSizesX.data());
     for (int i = 0; i < numPageSizes; ++i)
-        info("GL_VIRTUAL_PAGE_SIZE_X_ARB[%;] = %;", i, pageSizesX[i]);
+        globjects::info("GL_VIRTUAL_PAGE_SIZE_X_ARB[%;] = %;", i, pageSizesX[i]);
 
     std::vector<int> pageSizesY(numPageSizes);
     glGetInternalformativ(GL_TEXTURE_2D, GL_RGBA8, GL_VIRTUAL_PAGE_SIZE_Y_ARB
         , static_cast<GLsizei>(numPageSizes * sizeof(int)), pageSizesY.data());
     for (int i = 0; i < numPageSizes; ++i)
-        info("GL_VIRTUAL_PAGE_SIZE_Y_ARB[%;] = %;", i, pageSizesY[i]);
+        globjects::info("GL_VIRTUAL_PAGE_SIZE_Y_ARB[%;] = %;", i, pageSizesY[i]);
 
     std::vector<int> pageSizesZ(numPageSizes);
     glGetInternalformativ(GL_TEXTURE_2D, GL_RGBA8, GL_VIRTUAL_PAGE_SIZE_Z_ARB
         , static_cast<GLsizei>(numPageSizes * sizeof(int)), pageSizesZ.data());
     for (int i = 0; i < numPageSizes; ++i)
-        info("GL_VIRTUAL_PAGE_SIZE_Z_ARB[%;] = %;", i, pageSizesZ[i]);
+        globjects::info("GL_VIRTUAL_PAGE_SIZE_Z_ARB[%;] = %;", i, pageSizesZ[i]);
 
-    g_pageSize = ivec2(pageSizesX[0], pageSizesY[0]);
+    g_pageSize = glm::ivec2(pageSizesX[0], pageSizesY[0]);
     g_numPages   = g_textureSize / g_pageSize;
     g_totalPages = g_numPages.x * g_numPages.y;
 
     // Get maximum sparse texture size
 
     int maxSparseTextureSize;
     glGetIntegerv(GL_MAX_SPARSE_TEXTURE_SIZE_ARB, &maxSparseTextureSize);
-    info("GL_MAX_SPARSE_TEXTURE_SIZE_ARB = %d;", maxSparseTextureSize);
+    globjects::info("GL_MAX_SPARSE_TEXTURE_SIZE_ARB = %d;", maxSparseTextureSize);
 
-    g_texture = new Texture(GL_TEXTURE_2D);
+    g_texture = new globjects::Texture(GL_TEXTURE_2D);
     g_texture->ref();
 
     // make texture sparse
@@ -195,14 +132,14 @@ void mapNextPage()
         data[i] = static_cast<unsigned char>(255 - static_cast<unsigned char>(r(generator) * 255));
 
     // unmap oldest page
-    int oldestPage = (currentPage + g_totalPages - g_maxResidentPages) % g_totalPages;
-    ivec2 oldOffset = ivec2(oldestPage % g_numPages.x, oldestPage / g_numPages.x) * g_pageSize;
-    g_texture->pageCommitment(0, ivec3(oldOffset, 0), ivec3(g_pageSize, 1), GL_FALSE);
+    const auto oldestPage = (currentPage + g_totalPages - g_maxResidentPages) % g_totalPages;
+    const auto oldOffset = glm::ivec2(oldestPage % g_numPages.x, oldestPage / g_numPages.x) * g_pageSize;
+    g_texture->pageCommitment(0, glm::ivec3(oldOffset, 0), glm::ivec3(g_pageSize, 1), GL_FALSE);
 
     // map next page
-    ivec2 newOffset = ivec2(currentPage % g_numPages.x, currentPage / g_numPages.x) * g_pageSize;
+    glm::ivec2 newOffset = glm::ivec2(currentPage % g_numPages.x, currentPage / g_numPages.x) * g_pageSize;
 
-    g_texture->pageCommitment(0, ivec3(newOffset, 0), ivec3(g_pageSize, 1), GL_TRUE);
+    g_texture->pageCommitment(0, glm::ivec3(newOffset, 0), glm::ivec3(g_pageSize, 1), GL_TRUE);
     g_texture->subImage2D(0, newOffset, g_pageSize, GL_RGBA, GL_UNSIGNED_BYTE, data.data());
 
     currentPage = (currentPage + 1) % g_totalPages;
@@ -214,42 +151,73 @@ void draw()
 
     mapNextPage();
 
+    glViewport(0, 0, g_size.x, g_size.y);
     g_quad->draw();
 }
 
 
-/**
- * @brief This example shows how to set up a sparse texture and then map/unmap pages using the ARB_sparse_texture extension.
- *
- * See http://www.opengl.org/registry/specs/ARB/sparse_texture.txt
- */
+void error(int errnum, const char * errmsg)
+{
+    globjects::critical() << errnum << ": " << errmsg << std::endl;
+}
+
+void framebuffer_size_callback(GLFWwindow * /*window*/, int width, int height)
+{
+    g_size = glm::ivec2{ width, height };
+}
+
+void key_callback(GLFWwindow * window, int key, int /*scancode*/, int action, int /*modes*/)
+{
+    if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
+        glfwSetWindowShouldClose(window, true);
+}
+
+
 int main(int /*argc*/, char * /*argv*/[])
 {
     // Initialize GLFW
-    glfwInit();
+    if (!glfwInit())
+        return 1;
+
+    glfwSetErrorCallback(error);
+    glfwDefaultWindowHints();
+
+    glfwSetErrorCallback([](int /*error*/, const char * description) { puts(description); });
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
+
+    // Create a context and, if valid, make it current
+    GLFWwindow * window = glfwCreateWindow(320, 240, "globjects Sparse Textures", NULL, NULL);
+    if (window == nullptr)
+    {
+        globjects::critical() << "Context creation failed. Terminate execution.";
+
+        glfwTerminate();
+        return -1;
+    }
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    glfwMakeContextCurrent(window);
+
+    // Initialize globjects (internally initializes glbinding, and registers the current context)
+    globjects::init();
+    common::printContextInfo();
+
+    globjects::info() << "Press F5 to reload shaders." << std::endl;
+
 
-    GLFWwindow * window = createWindow();
     initialize();
+    glfwGetFramebufferSize(window, &g_size[0], &g_size[1]);
 
     // Main loop
     while (!glfwWindowShouldClose(window))
     {
         glfwPollEvents();
-
-        if (g_toggleFS)
-        {
-            deinitialize();
-            destroyWindow(window);
-            window = createWindow(!g_isFS);
-            initialize();
-
-            g_toggleFS = false;
-        }
-
         draw();
         glfwSwapBuffers(window);
     }
-
     deinitialize();
 
     // Properly shutdown GLFW