GLFW_CONNECTED Joystick vs Monitor

[cdelorme]

Not sure if this is a bug so much as unexpected behavior given that the documentation says to refer to the documentation (eg. glfw's), which doesn't really help since go is not C.

This fails:

func (self *Game) joysticks(joy, event int) {
    if event == glfw.Connected {
        // setup joystick
        self.Debug("joystick %d connected...", joy)
    } else if event == glfw.Disconnected {
        // teardown joystick
        self.Debug("joystick %d disconnected...", joy)
    }
}

This does not:

func (self *Game) joysticks(joy, event int) {
    if event == int(glfw.Connected) {
        // setup joystick
        self.Debug("joystick %d connected...", joy)
    } else if event == int(glfw.Disconnected) {
        // teardown joystick
        self.Debug("joystick %d disconnected...", joy)
    }
}

Is this expected? If not is there a recommended way to refactor glfw.Connected such that it can be used as a MonitorEvent as well as a JoystickEvent? Does anyone even use dynamic joystick plug-and-play (on linux /w xboxdrv all wireless joysticks in /dev/input/ exist up front so I don't haven't tested this really)?

[dmitshur]

First, what package are you using? v3.2/glfw?

Second, let me clarify. Are you saying both versions of those code compile, and the only difference is:

 func (self *Game) joysticks(joy, event int) {
-     if event == glfw.Connected {
+     if event == int(glfw.Connected) {
          // setup joystick
          self.Debug("joystick %d connected...", joy)
-     } else if event == glfw.Disconnected {
+     } else if event == int(glfw.Disconnected) {
          // teardown joystick
          self.Debug("joystick %d disconnected...", joy)
      }
  }

Yet one works but the other doesn't?

That's definitely very unexpected, and I guess it's a part of the cgo unpleasantness that I forgot about.

I don't have easy access to a monitor or joystick to connect/disconnect to test this.

Looking at the GLFW C API, I can confirm that both monitor and joystick connection callbacks indeed reuse the same defines:

• http://www.glfw.org/docs/latest/monitor_guide.html#monitor_event
  • https://github.com/glfw/glfw/blob/3.2/include/GLFW/glfw3.h#L1093
• http://www.glfw.org/docs/latest/input_guide.html#joystick_event
  • https://github.com/glfw/glfw/blob/3.2/include/GLFW/glfw3.h#L1110

In the Go code, we currently have:

// MonitorEvent corresponds to a monitor configuration event.
type MonitorEvent int

// Monitor events.
const (
    Connected    MonitorEvent = C.GLFW_CONNECTED
    Disconnected MonitorEvent = C.GLFW_DISCONNECTED
)

But there's nothing for joystick events. I think we can either add:

// JoystickEvent corresponds to a joystick configuration event.
type JoystickEvent int

// Joystick events.
const (
    JoystickConnected    JoystickEvent = C.GLFW_CONNECTED
    JoystickDisconnected JoystickEvent = C.GLFW_DISCONNECTED
)

Unlike in C, we can't reuse Connected and Disconnected identifiers for both types, because that would result in duplicate symbols in the package. (/cc @elmindreda FYI)

We could also add MonitorConnected, MonitorDisconnected and deprecate the current Connected/Disconnected.

Another alternative solution is to reuse the same type for both. That would keep us closer to the C API, at least in spirit.

For example:

// MonitorJoystickEvent corresponds to a monitor/joystick configuration event.
type MonitorJoystickEvent int

// Monitor/joystick events.
const (
    Connected    MonitorJoystickEvent = C.GLFW_CONNECTED
    Disconnected MonitorJoystickEvent = C.GLFW_DISCONNECTED
)

Or give it a better name:

// PeripheralEvent corresponds to a peripheral device configuration event.
type PeripheralEvent int

// Monitor/joystick events.
const (
    Connected    PeripheralEvent = C.GLFW_CONNECTED
    Disconnected PeripheralEvent = C.GLFW_DISCONNECTED
)

Other possible names include DeviceEvent.

[cdelorme]

Ah, sorry for the missing information and confusion:

1. I am using 3.2
2. only the one with explicit casting works, the other fails with type-mismatch at build time
3. the controller connect/disconnect behavior is almost certainly my own problem, I was more curious if anyone finds benefit in bothering to use those callbacks, since you just end up polling controller states anyway and it does not appear to crash when I poll disconnected controllers. Coming from SDL where you had to "open" and initialize controllers is what makes this feel unnecessary in glfw.

Given that the glfw documentation refers to a single GLFW_CONNECTED constant, I think it would make the most sense to consolidate the types and reuse the constant at both locations, but I wasn't sure if it was intentionally not implemented this way. If we did add new joystick events the callback would also need to be updated to work with the new type otherwise I'd be back to casting.

[tapir]

I like the idea of renaming it to PeripheralEvent. I think that's what we should do next version since it will break API.

But.... that will not solve @cdelorme's problem. Go does not allow implicit type casts.
Second example is how it should be.

If we want to eliminate casting there we need to do this (which is inconsistent with the rest of the API so I don't like it but as always I'm open to discussion)

const (
    Connected  = C.GLFW_CONNECTED
    Disconnected = C.GLFW_DISCONNECTED
)

[cdelorme]

If we want the bindings to provide consistent resource prefixes to each event then some redundancy is in order:

// PeripheralEvent corresponds to a peripheral device configuration event.
type PeripheralEvent int

// Monitor/joystick events.
const (
    Connected    PeripheralEvent = C.GLFW_CONNECTED
    Disconnected PeripheralEvent = C.GLFW_DISCONNECTED
)

// type MonitorEvent int
type MonitorEvent PeripheralEvent

// Monitor specific constants for consistent API
const (
    MonitorConnected MonitorEvent = Connected
    MonitorDisconnected MonitorEvent = Disconnected
)

// type JoystickEvent int
type JoystickEvent PeripheralEvent

// Joystick specific constants for consistent API
const (
    JoystickConnected JoystickEvent = Connected
    JoystickDisconnected JoystickEvent = Disconnected
)

Not sure if there is any value at that point in having PeripheralEvent, but keeping things separate without adding unused constants means more C. references:

type MonitorEvent PeripheralEvent

// Monitor specific constants for consistent API
const (
    MonitorConnected MonitorEvent = C.GLFW_CONNECTED
    MonitorDisconnected MonitorEvent = C.GLFW_DISCONNECTED
)

type JoystickEvent PeripheralEvent

// Joystick specific constants for consistent API
const (
    JoystickConnected JoystickEvent = C.GLFW_CONNECTED
    JoystickDisconnected JoystickEvent = C.GLFW_DISCONNECTED
)

[pwaller]

Hopefully this is addressed in #256, which introduces glfw 3.3 support. If not please report back and we can reopen.