Merge branch 'master' into showwindow

Conflicts:
	readme.html

tests/CMakeLists.txt

@@ -14,6 +14,8 @@ include_directories(${GLFW_SOURCE_DIR}/include
 
 set(GETOPT ${GLFW_SOURCE_DIR}/support/getopt.h
            ${GLFW_SOURCE_DIR}/support/getopt.c)
+set(TINYCTHREAD ${GLFW_SOURCE_DIR}/support/tinycthread.h
+                ${GLFW_SOURCE_DIR}/support/tinycthread.c) 
 
 add_executable(clipboard clipboard.c ${GETOPT})
 add_executable(defaults defaults.c)
@@ -37,13 +39,20 @@ set_target_properties(sharing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Sharing")
 add_executable(tearing WIN32 MACOSX_BUNDLE tearing.c)
 set_target_properties(tearing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Tearing")
 
+add_executable(threads WIN32 MACOSX_BUNDLE threads.c ${TINYCTHREAD})
+set_target_properties(threads PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Threads")
+
 add_executable(title WIN32 MACOSX_BUNDLE title.c)
 set_target_properties(title PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Title")
 
 add_executable(windows WIN32 MACOSX_BUNDLE windows.c)
 set_target_properties(windows PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Windows")
 
-set(WINDOWS_BINARIES accuracy sharing tearing title windows)
+if (BUILD_SHARED_LIBS)
+    target_link_libraries(threads ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+set(WINDOWS_BINARIES accuracy sharing tearing threads title windows)
 set(CONSOLE_BINARIES clipboard defaults events fsaa fsfocus gamma glfwinfo
                      iconify joysticks modes peter reopen)
 

tests/glfwinfo.c

@@ -290,6 +290,9 @@ int main(int argc, char** argv)
                get_glfw_profile_name(glfwGetWindowParam(window, GLFW_OPENGL_PROFILE)));
     }
 
+    printf("OpenGL context debug flag saved by GLFW: %s\n",
+           glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT) ? "true" : "false");
+
     printf("OpenGL context renderer string: \"%s\"\n", glGetString(GL_RENDERER));
     printf("OpenGL context vendor string: \"%s\"\n", glGetString(GL_VENDOR));
 

tests/threads.c

@@ -0,0 +1,131 @@
+//========================================================================
+// Multithreading test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test is intended to verify whether the OpenGL context part of
+// the GLFW API is able to be used from multiple threads
+//
+//========================================================================
+
+#include <GL/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+
+#include "tinycthread.h"
+
+typedef struct
+{
+    GLFWwindow window;
+    const char* title;
+    float r, g, b;
+    thrd_t id;
+} Thread;
+
+static volatile GLboolean running = GL_TRUE;
+
+static int thread_main(void* data)
+{
+    const Thread* thread = (const Thread*) data;
+
+    glfwMakeContextCurrent(thread->window);
+    assert(glfwGetCurrentContext() == thread->window);
+
+    glfwSwapInterval(1);
+
+    while (running)
+    {
+        const float v = (float) fabs(sin(glfwGetTime() * 2.f));
+        glClearColor(thread->r * v, thread->g * v, thread->b * v, 0.f);
+
+        glClear(GL_COLOR_BUFFER_BIT);
+        glfwSwapBuffers(thread->window);
+    }
+
+    glfwMakeContextCurrent(NULL);
+    return 0;
+}
+
+int main(void)
+{
+    int i, result;
+    Thread threads[] =
+    {
+        { NULL, "Red", 1.f, 0.f, 0.f, 0 },
+        { NULL, "Green", 0.f, 1.f, 0.f, 0 },
+        { NULL, "Blue", 0.f, 0.f, 1.f, 0 }
+    };
+    const int count = sizeof(threads) / sizeof(Thread);
+
+    if (!glfwInit())
+    {
+        fprintf(stderr, "Failed to initialize GLFW: %s\n",
+                glfwErrorString(glfwGetError()));
+        exit(EXIT_FAILURE);
+    }
+
+    for (i = 0;  i < count;  i++)
+    {
+        threads[i].window = glfwCreateWindow(200, 200,
+                                             GLFW_WINDOWED,
+                                             threads[i].title,
+                                             NULL);
+        if (!threads[i].window)
+        {
+            fprintf(stderr, "Failed to open GLFW window: %s\n",
+                    glfwErrorString(glfwGetError()));
+            exit(EXIT_FAILURE);
+        }
+
+        glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
+
+        if (thrd_create(&threads[i].id, thread_main, threads + i) !=
+            thrd_success)
+        {
+            fprintf(stderr, "Failed to create secondary thread\n");
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    while (running)
+    {
+        assert(glfwGetCurrentContext() == NULL);
+
+        glfwWaitEvents();
+
+        for (i = 0;  i < count;  i++)
+        {
+            if (glfwGetWindowParam(threads[i].window, GLFW_CLOSE_REQUESTED))
+                running = GL_FALSE;
+        }
+    }
+
+    for (i = 0;  i < count;  i++)
+        thrd_join(threads[i].id, &result);
+
+    exit(EXIT_SUCCESS);
+}
+