• Vlad Levenfeld (28/28) May 24 2014 Any attempt to set callbacks in GLFW returns a null and the
• Rene Zwanenburg (3/31) May 24 2014 glfwSetErrorCallback returns the previous callback, so it makes
• Andrej Mitrovic via Digitalmars-d-learn (50/55) May 24 2014 It's ok if this fails because this is how it's documented:
• Vlad Levenfeld (4/4) May 24 2014 Haha, I should have read more carefully. Must have looked at that

"Vlad Levenfeld" <vlevenfeld gmail.com> writes:

Any attempt to set callbacks in GLFW returns a null and the 
callback doesn't work.

The first enforcement fails in this example:

DerelictGLFW3.load ();
enforce (glfwSetErrorCallback (&error_callback));
enforce (glfwInit (), "glfwInit failed");
window = glfwCreateWindow (screen_dims.x, screen_dims.y, "sup", 
null, null);
glfwMakeContextCurrent (window);
glfwSwapInterval (0);

If I forget about the callbacks, everything functions normally (I 
can render, etc).
Here is error_callback:

static extern (C) void error_callback (int, const (char)* error) 
nothrow {
	import std.c.stdio: fprintf, stderr;
	fprintf (stderr, "error glfw: %s\n", error);
}

It is a static member function but pulling it out to the module 
scope changes nothing.
It doesn't work when I do it from the main thread or a secondary 
thread.

The load-set_error_callback-glfwInit sequence is recommended 
everywhere I look up D's GLFW bindings, so apparently this works 
for other people and I must be missing something.

And in the event that this can't be solved, I suppose the thing 
to do is to either poll for input events manually or try to get 
that part working in C then call it from D?

"Rene Zwanenburg" <renezwanenburg gmail.com> writes:

On Saturday, 24 May 2014 at 13:31:46 UTC, Vlad Levenfeld wrote:
 Any attempt to set callbacks in GLFW returns a null and the 
 callback doesn't work.

 The first enforcement fails in this example:

 DerelictGLFW3.load ();
 enforce (glfwSetErrorCallback (&error_callback));
 enforce (glfwInit (), "glfwInit failed");
 window = glfwCreateWindow (screen_dims.x, screen_dims.y, "sup", 
 null, null);
 glfwMakeContextCurrent (window);
 glfwSwapInterval (0);

 If I forget about the callbacks, everything functions normally 
 (I can render, etc).
 Here is error_callback:

 static extern (C) void error_callback (int, const (char)* 
 error) nothrow {
 	import std.c.stdio: fprintf, stderr;
 	fprintf (stderr, "error glfw: %s\n", error);
 }

 It is a static member function but pulling it out to the module 
 scope changes nothing.
 It doesn't work when I do it from the main thread or a 
 secondary thread.

 The load-set_error_callback-glfwInit sequence is recommended 
 everywhere I look up D's GLFW bindings, so apparently this 
 works for other people and I must be missing something.

 And in the event that this can't be solved, I suppose the thing 
 to do is to either poll for input events manually or try to get 
 that part working in C then call it from D?

glfwSetErrorCallback returns the previous callback, so it makes 
sense null is returned on the first call.

Andrej Mitrovic via Digitalmars-d-learn writes:

On 5/24/14, Vlad Levenfeld via Digitalmars-d-learn
<digitalmars-d-learn puremagic.com> wrote:
 Any attempt to set callbacks in GLFW returns a null and the
 callback doesn't work.

 The first enforcement fails in this example:

 DerelictGLFW3.load ();
 enforce (glfwSetErrorCallback (&error_callback));

It's ok if this fails because this is how it's documented:

*   return The previously set callback, or `NULL` if no callback was set or an
*  error occurred.

Below is a full snippet of using DerelictGLFW and a simple escape key binding:

-----
import derelict.glfw3.glfw3;

import std.conv;
import std.exception;
import std.stdio;

shared static this()
{
    DerelictGLFW3.load();
}

extern(C) void error_callback(int error, const(char)* description) nothrow
{
    printf("%s %s", error, description);
}

int main()
{
    /* Initialize the library */
    enforce(glfwInit());

    glfwSetErrorCallback(&error_callback);

    GLFWwindow* window;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", null, null);
    scope(exit) glfwTerminate();
    enforce(window !is null);

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    extern(C) void onKeyEvent(GLFWwindow* window, int key, int
scancode, int state, int modifier) nothrow
    {
        if (key == GLFW_KEY_ESCAPE && state == GLFW_PRESS)
            glfwSetWindowShouldClose(window, true);
    }

    glfwSetKeyCallback(window, &onKeyEvent);

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */

        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    return 0;
}
-----

"Vlad Levenfeld" <vlevenfeld gmail.com> writes:

Haha, I should have read more carefully. Must have looked at that 
line in the doc a dozed times and never picked up on that detail.

Your example worked for me - I wasn't calling "glfwPollEvents."

Thanks!