OpenTK Mac OS X support.

Awesome news! Let me know if you need help with anything.

As a rule of thumb, just write a DllImport with the correct signature and let the runtime handle the details for you (pinning etc), unless it is performance-critical code.

For example:

// C function
#define bool char
typedef struct { ... } SomeStruct;
bool Foo(SomeStruct *data);
 
// C# - whichever of the following makes the most sense
[DllImport("library")]
bool Foo(SomeStruct[] data);
 
// or, if SomeStruct is a struct (i.e. value object):
[DllImport("library")]
bool Foo(ref SomeStruct data);
 
// or, if SomeStruct is a class (i.e. reference object):
[DllImport("library")]
bool Foo(SomeStruct data);

This should cover just about 90% of all p/invoke cases.

Void pointers can be turned into IntPtrs, and char arrays should be made into strings (in parameters) or StringBuilders (out parameters). Generally, the biggest issue is converting structs with unions or embedded arrays/strings - just make a post if anything strange shows up ;)

Another complication has to do with 64bit datatypes: do ints change bitness from 32- to 64bit compilers (i.e. 32bit on 32bit compilers and 64bit on 64bit compilers)? If so, int parameters should be defined as IntPtrs, which is a bit ugly (but necessary).

Oh, one other thing I wanted to ask. Is there support for the type of event handling where the user clicks the close box, and the program asks if they want to save before quitting (or something like that). I already have support for this sort of thing written into the carbon wrapper, so that it can cancel a window close event if the program / user input requires it.

I just ran the GLSL example, and it gives an error message about requiring OpenGL 2.0 and says it will abort, but then it runs anyway. Looking at the extensions supported by my card, I see things like:
gl_apple_vertex_program_evaluators
gl_arb_fragment_program
gl_arb_fragment_shader
gl_arb_shader_objects
gl_arb_shading_language_100
gl_arb_vertex_program
gl_arb_vertex_shader
gl_version_1_1
gl_version_1_2

but no other gl_versions are listed.

And my the OpenGL driver info listed is
Intel GMA 950 OpenGL Engine, Intel Inc., 1.2 APPLE-1.4.56

So shaders are supported, even though I don't have higher than OpenGL 1.2 ?

Great work! I won't have time to review the code for another 24 hours or so, but I can respond to your questions :)

[MacOS vs OSX]
No problem, MacOS looks better too.

[Font artifacts]
This has to do with sampling/texture coordinates, it happens on some cards/drivers but not on others. I'll loosen the packing by 1 pixel - this should take care of these artifacts.

[GLU tesselate]
This looks like a Mono problem (doesn't work on Linux either), but I haven't bothered to investigate yet. I'm looking for a managed alternative - if one exists, I'll be happy to see GLU go away.

[Window close event]
The implementation is a bit hairy. There are three ways to close the window:

1. User calls GameWindow.Exit. This terminates the main loop. Then the Unload event is fired, the context is disposed and INativeGLWindow.DestroyWindow() is called. Finally, all pending events are processed until GameWindow.Exists becomes false.
2. User clicks the "Close" button. INativeGLWindow.ProcessEvents detects this and raises the INativeGLWindow.Destroy event, which is handled by GameWindow.glWindow_Destroy. GameWindow.glWindow_Destroy valls GameWindow.Exit and the rest work out as above.
3. User calls GameWindow.Dispose. This calls GraphicsContext.Dispose and INativeGLWindow.Dispose, but I haven't worked out the details yet (presumably it should call GameWindow.Exit instead).

[Window resize event]
GL.Viewport generally belongs to a GameWindow.Resize event handler. As long as OnResizeInternal is called, the resize event will be raised.

(The On*Internal methods will potentially perform some bookkeeping before raising the actual events. They also make sure that things will work correctly if the user overrides the On* methods - e.g. OnUpdate - and forgets to call base.OnUpdate).

[Class factory for platforms]
I was planning to do this, but I didn't think a MacOS port would become reality so soon. :)

I think you have such a system in place for AgateLib? I'd be very interested in such an implementation.

[GameWindowExitException]
It is the only way (I know of) to stop the main loop asynchronously. I.e:

override void OnLoad(...)
{
    if opengl version < 2.0
        Exit();
    use opengl 2.0
}

Exit() must stop control before it reaches the "use opengl 2.0" line (otherwise it will crash!). To the best of my knowledge, an exception is the only method to achieve this.

I added this exception very reluctantly, but I really cannot see a better way.

If you have a custom main loop, the solution is simple: don't call Exit() (Exit() is specific to the Run() method - should document this better). Since you have control over the main loop, you are free to use a flag (or any other method you can think of).

[Exit event with cancel support]
I'm planning to add this, so this code is useful.

[GLSL]
Intel GMA 950 OpenGL Engine, Intel Inc., 1.2 APPLE-1.4.56
OpenTK reports the version from GL.GetString(): "1.2 APPLE-1.4.56" - I don't know if there's a better way.

I'll update the app to test for GLSL support explicitly, instead of relying on gl_version_2_0 being available.

[OpenAL]
This doesn't look very good. The attributes look bogus - they should contain things like frequency (44100) etc. At least it doesn't crash :)

I'm still working on AudioContext. Should have a couple of examples ready later today, that test audio playback and audio effects.