Go bindings for OpenGL (generated via glow)

# gl [![Build Status](https://github.com/go-gl/gl/actions/workflows/main.yml/badge.svg)](https://github.com/go-gl/gl/actions/workflows/main.yml) [![Go Reference](https://pkg.go.dev/badge/github.com/go-gl/gl.svg)](https://pkg.go.dev/github.com/go-gl/gl)

This repository holds Go bindings to various OpenGL versions. They are auto-generated using [Glow](https://github.com/go-gl/glow).

Features:
- Go functions that mirror the C specification using Go types.
- Support for multiple OpenGL APIs (GL/GLES/EGL/WGL/GLX/EGL), versions, and profiles.
- Support for extensions (including debug callbacks).

Requirements:
- A cgo compiler (typically gcc).
- On Ubuntu/Debian-based systems, the `libgl1-mesa-dev` package.

## Usage

Use `go get -u` to download and install the prebuilt packages. The prebuilt packages support OpenGL versions 2.1, 3.1, 3.2, 3.3, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6 across both the core and compatibility profiles and include all extensions. Pick whichever one(s) you need:

    go get -u github.com/go-gl/gl/v{3.2,3.3,4.1,4.2,4.3,4.4,4.5,4.6}-{core,compatibility}/gl
    go get -u github.com/go-gl/gl/v3.1/gles2
    go get -u github.com/go-gl/gl/v2.1/gl

Once the bindings are installed you can use them with the appropriate import statements.

```Go
package main

import "github.com/go-gl/gl/v3.3-core/gl"

func main() {
	window := ... // Open a window.
	window.MakeContextCurrent()

	// Important! Call gl.Init only under the presence of an active OpenGL context,
	// i.e., after MakeContextCurrent.
	if err := gl.Init(); err != nil {
		log.Fatalln(err)
	}
}
```

The `gl` package contains the OpenGL functions and enumeration values for the imported version. It also contains helper functions for working with the API. Of note is `gl.Ptr` which takes a Go array or slice or pointer and returns a corresponding `uintptr` to use with functions expecting data pointers. Also of note is `gl.Str` which takes a null-terminated Go string and returns a corresponding `*int8` to use with functions expecting character pointers.

A note about threading and goroutines. The bindings do not expose a mechanism to make an OpenGL context current on a different thread so you must restrict your usage to the thread on which you called `gl.Init()`. To do so you should use [LockOSThread](https://code.google.com/p/go-wiki/wiki/LockOSThread).

## Examples

Examples illustrating how to use the bindings are available in the [example](https://github.com/go-gl/example) repo. There are examples for [OpenGL 4.1 core](https://github.com/go-gl/example/tree/master/gl41core-cube) and [OpenGL 2.1](https://github.com/go-gl/example/tree/master/gl21-cube).

## Function Loading

The `procaddr` package contains platform-specific functions for [loading OpenGL functions](https://www.opengl.org/wiki/Load_OpenGL_Functions). Calling `gl.Init()` uses the `auto` subpackage to automatically select an appropriate implementation based on the build environment. If you want to select a specific implementation you can use the `noauto` build tag and the `gl.InitWithProcAddrFunc` initialization function.

## Go >=1.14 and `checkptr`

In version 1.14 of Go, the race detector added `checkptr` instrumentation. This compilation option ensures that programs follow `unsafe.Pointer` safety rules. See here for details: https://golang.org/doc/go1.14#compiler.

If enabled, there is a high chance that it will cause program termination when calling specific OpenGL functions, with a message like this:

```
fatal error: checkptr: pointer arithmetic computed bad pointer value
```

The reported call stack will point to a function like `gl.VertexAttribPointer()` that receives an `unsafe.Pointer` as parameter.
In case such function requires an "offset" passed in as a pointer (in the low-level API), a different signature needs to be used in order to satisfy the detector.

For this purpose `glow` generates "override" functions which have a different signature, taking `uintptr` instead. These functions have the suffix `WithOffset` (or similar) in their name.
For the previous example, it would be `gl.VertexAttribPointerWithOffset()`.

Not all such functions have an appropriate override! In case you stumble over such an error, and the override is missing, you have the following options:
* Disable the detector by building your program with `-gcflags=all=-d=checkptr=0`
* Report the missing function(s) as [issue for `glow`](https://github.com/go-gl/glow/issues)
* Possibly even create a pull-request for `glow` with the missing override yourself, and re-generate the `gl` bindings.

## Generating

These gl bindings are generated using the [Glow](https://github.com/go-gl/glow) generator. Only developers of this repository need to do this step.

It is required to have `glow` source in a sibling directory to `go-gl/gl` since relative paths are used for generation (see `generate.go`).
For non-module-aware cases, this means `glow` needs to be in the same Go workspace as `go-gl/gl`.
For module-aware cases, `go-gl/glow` needs to be checked out parallel to `go-gl/gl`. 

Perform generation with the following:

```bash
cd path/to/go-gl/gl
go generate -tags=gen .
```

More information about these bindings can be found in the [Glow repository](https://github.com/go-gl/glow).


[![Tests](https://github.com/go-gl/glfw/actions/workflows/tests.yml/badge.svg)](https://github.com/go-gl/glfw/actions/workflows/tests.yml)
[![Static Analysis](https://github.com/go-gl/glfw/actions/workflows/analysis.yml/badge.svg)](https://github.com/go-gl/glfw/actions/workflows/analysis.yml)
[![GoDoc](https://godoc.org/github.com/go-gl/glfw/v3.4/glfw?status.svg)](https://godoc.org/github.com/go-gl/glfw/v3.4/glfw)

# GLFW 3.4 for Go

## Installation

* GLFW C library source is included and built automatically as part of the Go package. But you need to make sure you have dependencies of GLFW:
	* On macOS, you need Xcode or Command Line Tools for Xcode (`xcode-select --install`) for required headers and libraries.
	* On Ubuntu/Debian-like Linux distributions, the default Linux build enables both X11 and Wayland, so you need `libgl1-mesa-dev`, `xorg-dev`, `libwayland-dev`, `libxkbcommon-dev` and `wayland-protocols`.
	* On CentOS/Fedora-like Linux distributions, you need `libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel mesa-libGL-devel libXi-devel libXxf86vm-devel` packages.
	* On FreeBSD, you need the package `pkgconf`. To build for X, you also need the package `xorg`; and to build for Wayland, you need the package `wayland`.
	* On NetBSD, to build for X, you need the X11 sets installed. These are included in all graphical installs, and can be added to the system with `sysinst(8)` on non-graphical systems. Wayland support is incomplete, due to missing wscons support in upstream GLFW. To attempt to build for Wayland, you need to install the `wayland libepoll-shim` packages and set the environment variable `PKG_CONFIG_PATH=/usr/pkg/libdata/pkgconfig`.
	* On OpenBSD, you need the X11 sets. These are installed by default, and can be added from the ramdisk kernel at any time.
	* See [here](http://www.glfw.org/docs/latest/compile.html#compile_deps) for full details.
* Go 1.4+ is required on Windows (otherwise you must use MinGW v4.8.1 exactly, see [Go issue 8811](https://github.com/golang/go/issues/8811)).

```
go get github.com/go-gl/glfw/v3.4/glfw
```

### OpenGL ES

If your target system only provides an OpenGL ES implementation (true for some ARM boards), you need to link against that implementation.
You do this by defining the appropriate build tags, e.g.

```
go get -tags=gles2 github.com/go-gl/glfw/v3.4/glfw
```

Supported tags are `gles1`, `gles2`, `gles3` and `vulkan`.
Note that required packages might differ from those listed above; consult your hardware's documentation.

## Usage

```Go
package main

import (
	"runtime"
	"github.com/go-gl/glfw/v3.4/glfw"
)

func init() {
	// This is needed to arrange that main() runs on main thread.
	// See documentation for functions that are only allowed to be called from the main thread.
	runtime.LockOSThread()
}

func main() {
	err := glfw.Init()
	if err != nil {
		panic(err)
	}
	defer glfw.Terminate()

	window, err := glfw.CreateWindow(640, 480, "Testing", nil, nil)
	if err != nil {
		panic(err)
	}

	window.MakeContextCurrent()

	for !window.ShouldClose() {
		// Do OpenGL stuff.
		window.SwapBuffers()
		glfw.PollEvents()
	}
}
```

## Changelog

### GLFW 3.4 Specific Changes

* This section is cumulative for the v3.4 branch and includes changes from multiple commits.
* Added support for dynamic runtime switching between X11 and Wayland on Linux.
* Replaced compile-time Wayland icon checking with `glfwGetPlatform()`.
* Mapped `GLFW_FEATURE_UNAVAILABLE` and `GLFW_FEATURE_UNIMPLEMENTED` to prevent go panics on unsupported platform features.
* Mapped `GLFW_CURSOR_UNAVAILABLE` and `GLFW_PLATFORM_UNAVAILABLE`.
* Added function `GetPlatform`.
* Added function `PlatformSupported`.
* Added function `InitAllocator`.
* Added function `InitVulkanLoader`.
* Added function `GetError`.
* Added function `GetPhysicalDevicePresentationSupport`.
* Added function `Window.GetTitle`.
* Added function `Window.GetCocoaView`.
* Added hint `MousePassthrough`.
* Added hint `PositionX`.
* Added hint `PositionY`.
* Added hint `ContextDebug`.
* Added hint `ContextNoError`.
* Added hint `AnglePlatformType`.
* Added hint `PlatformHint`.
* Added hint `ScaleFramebuffer`.
* Added hint `Win32KeyboardMenu`.
* Added hint `Win32ShowDefault`.
* Added hint `WaylandAppID`.
* Added hint `WaylandLibdecor`.
* Added hint `X11XcbVulkanSurface`.
* Added hint value `AnyPosition`.
* Added hint value `WaylandPreferLibdecor`.
* Added hint value `WaylandDisableLibdecor`.
* Added cursor mode value `CursorCaptured`.
* `GLFW_UNLIMITED_MOUSE_BUTTONS` is not mapped because it is not present in the vendored GLFW C revision used by this package.
* Added multiple new standard cursors like `PointingHandCursor`, `ResizeEWCursor`, etc.
* Added `AnglePlatformType*` hint values for configuring ANGLE rendering backend.
* Added `Platform` type and values (`AnyPlatform`, `PlatformWin32`, `PlatformCocoa`, `PlatformWayland`, `PlatformX11`, `PlatformNull`).

### GLFW 3.3 Specific Changes
- Joystick functions now uses receivers instead of passing the joystick ID as argument.
- Vulkan methods are intentionally not implemented. `Window.Handle` can be used to create a Vulkan surface via the [this](https://github.com/vulkan-go/vulkan) package.

* Renamed `Window.GLFWWindow` to `Window.Handle`
* Added function `Window.SetAttrib`.
* Added function `Window.RequestAttention`.
* Added function `Window.GetContentScale`.
* Added function `Window.GetOpacity`.
* Added function `Window.SetOpacity`.
* Added function `Window.SetMaximizeCallback`.
* Added function `Window.SetContentScaleCallback`.
* Added function `Monitor.GetWorkarea`.
* Added function `Monitor.GetContentScale`.
* Added function `Monitor.SetUserPointer`.
* Added function `Monitor.GetUserPointer`.
* Added function `InitHint`.
* Added function `RawMouseMotionSupported`
* Added function `GetKeyScancode`.
* Added function `WindowHintString`.
* Added function `GetClipboardString`.
* Added function `SetClipboardString`.
* Added function `Joystick.GetHats`.
* Added function `Joystick.IsGamepad`.
* Added function `Joystick.GetGUID`.
* Added function `Joystick.GetGamepadName`.
* Added function `Joystick.GetGamepadState`.
* Added function `Joystick.SetUserPointer`.
* Added function `Joystick.GetUserPointer`.
* Added function `UpdateGamepadMappings`.
* Added function `SetX11SelectionString`.
* Added function `GetX11SelectionString`.
* Added gamepad button IDs.
* Added gamepad axis IDs.
* Added joystick hat state IDs.
* Added ModifierKey `ModCapsLock`.
* Added ModifierKey `ModNumLock`
* Added InputMode `LockKeyMods`.
* Added InputMode `RawMouseMotion`.
* Added hint `Hovered`.
* Added hint `CenterCursor`.
* Added hint `TransparentFramebuffer`.
* Added hint `FocusOnShow`.
* Added hint `ScaleToMonitor`.
* Added hint `JoystickHatButtons`.
* Added hint `CocoaChdirResources`.
* Added hint `CocoaMenubar`.
* Added hint `TransparentFramebuffer`.
* Added hint value `OSMesaContextAPI`.
* Added hint value `CocoaGraphicsSwitching`.
* Added hint value `CocoaRetinaFramebuffer`.
* Added string hint value `CocoaFrameNAME`.
* Added string hint value `X11ClassName`.
* Added string hint value `X11InstanceName`.
* `MonitorEvent` renamed to `PeripheralEvent` for reuse with joystick events.
* `Joystick.GetButtons` Returns `[]Action` instead of `[]byte`.
* `SetMonitorCallback` Returns `MonitorCallback`.
* `Focus` No longer returns an error.
* `Iconify` No longer returns an error.
* `Maximize` No longer returns an error.
* `Restore` No longer returns an error.
* `GetClipboardString` No longer returns an error.


### GLFW 3.2 Specific Changes
- Easy `go get` installation. GLFW source code is now included in-repo and compiled in so you don't have to build GLFW on your own and distribute shared libraries. The revision of GLFW C library used is listed in [GLFW_C_REVISION.txt](https://github.com/go-gl/glfw/blob/master/v3.2/glfw/GLFW_C_REVISION.txt) file.
- The error callback is now set internally. Functions return an error with corresponding code and description (do a type assertion to glfw3.Error for accessing the variables) if the error is recoverable. If not a panic will occur.

* Added function `Window.SetSizeLimits`.
* Added function `Window.SetAspectRatio`.
* Added function `Window.SetMonitor`.
* Added function `Window.Maximize`.
* Added function `Window.SetIcon`.
* Added function `Window.Focus`.
* Added function `GetKeyName`.
* Added function `VulkanSupported`.
* Added function `GetTimerValue`.
* Added function `GetTimerFrequency`.
* Added function `WaitEventsTimeout`.
* Added function `SetJoystickCallback`.
* Added window hint `Maximized`.
* Added hint `NoAPI`.
* Added hint `NativeContextAPI`.
* Added hint `EGLContextAPI`.


### GLFW 3.1 Specific Changes
* Added type `Cursor`.
* Added function `Window.SetDropCallback`.
* Added function `Window.SetCharModsCallback`.
* Added function `PostEmptyEvent`.
* Added function `CreateCursor`.
* Added function `CreateStandardCursor`.
* Added function `Cursor.Destroy`.
* Added function `Window.SetCursor`.
* Added function `Window.GetFrameSize`.
* Added window hint `Floating`.
* Added window hint `AutoIconify`.
* Added window hint `ContextReleaseBehavior`.
* Added window hint `DoubleBuffer`.
* Added hint value `AnyReleaseBehavior`.
* Added hint value `ReleaseBehaviorFlush`.
* Added hint value `ReleaseBehaviorNone`.
* Added hint value `DontCare`.

### API changes
* `Window.Iconify` Returns an error.
* `Window.Restore` Returns an error.
* `Init` Returns an error instead of `bool`.
* `GetJoystickAxes` No longer returns an error.
* `GetJoystickButtons` No longer returns an error.
* `GetJoystickName` No longer returns an error.
* `GetMonitors` No longer returns an error.
* `GetPrimaryMonitor` No longer returns an error.
* `Monitor.GetGammaRamp` No longer returns an error.
* `Monitor.GetVideoMode` No longer returns an error.
* `Monitor.GetVideoModes` No longer returns an error.
* `GetCurrentContext` No longer returns an error.
* `Window.SetCharCallback` Accepts `rune` instead of `uint`.
* Added type `Error`.
* Removed `SetErrorCallback`.
* Removed error code `NotInitialized`.
* Removed error code `NoCurrentContext`.
* Removed error code `InvalidEnum`.
* Removed error code `InvalidValue`.
* Removed error code `OutOfMemory`.
* Removed error code `PlatformError`.
* Removed `KeyBracket`.
* Renamed `Window.SetCharacterCallback` to `Window.SetCharCallback`.
* Renamed `Window.GetCursorPosition` to `GetCursorPos`.
* Renamed `Window.SetCursorPosition` to `SetCursorPos`.
* Renamed `CursorPositionCallback` to `CursorPosCallback`.
* Renamed `Window.SetCursorPositionCallback` to `SetCursorPosCallback`.
* Renamed `VideoMode` to `VidMode`.
* Renamed `Monitor.GetPosition` to `Monitor.GetPos`.
* Renamed `Window.GetPosition` to `Window.GetPos`.
* Renamed `Window.SetPosition` to `Window.SetPos`.
* Renamed `Window.GetAttribute` to `Window.GetAttrib`.
* Renamed `Window.SetPositionCallback` to `Window.SetPosCallback`.
* Renamed `PositionCallback` to `PosCallback`.
* Ranamed `Cursor` to `CursorMode`.
* Renamed `StickyKeys` to `StickyKeysMode`.
* Renamed `StickyMouseButtons` to `StickyMouseButtonsMode`.
* Renamed `ApiUnavailable` to `APIUnavailable`.
* Renamed `ClientApi` to `ClientAPI`.
* Renamed `OpenglForwardCompatible` to `OpenGLForwardCompatible`.
* Renamed `OpenglDebugContext` to `OpenGLDebugContext`.
* Renamed `OpenglProfile` to `OpenGLProfile`.
* Renamed `SrgbCapable` to `SRGBCapable`.
* Renamed `OpenglApi` to `OpenGLAPI`.
* Renamed `OpenglEsApi` to `OpenGLESAPI`.
* Renamed `OpenglAnyProfile` to `OpenGLAnyProfile`.
* Renamed `OpenglCoreProfile` to `OpenGLCoreProfile`.
* Renamed `OpenglCompatProfile` to `OpenGLCompatProfile`.
* Renamed `KeyKp...` to `KeyKP...`.


glfw

Pure Go math package specialized for 3D math, with inspiration from GLM

# MathGL [![Build Status](https://travis-ci.org/go-gl/mathgl.svg?branch=master)](https://travis-ci.org/go-gl/mathgl) [![GoDoc](https://godoc.org/github.com/go-gl/mathgl?status.svg)](https://godoc.org/github.com/go-gl/mathgl)

This is a Go matrix and vector math library specialized for Open GL graphics capabilities.

This package is made primarily with code generation for the basic vector and matrix operations, though and functionality beyond that is handwritten.

Vectors and matrices are stored in Column Major Order, just like OpenGL, which means the "transpose" argument should be **false** when passing in vectors and matrices using this package.

This package is split into two sub-packages. The package `mgl32` deals with 32-bit floats, and `mgl64` deals with 64-bit ones. Generally you'll use the 32-bit ones with OpenGL, but the 64-bit one is available in case you use the double extension or simply want to do higher precision 3D math without OpenGL.

The old repository, before the split between the 32-bit and 64-bit subpackages, is kept at github.com/Jragonmiris/mathgl (the old repository path), but is no longer maintained.

Examples can be found in [github.com/go-gl/example](https://github.com/go-gl/example).

Why am I not getting what I see on github!?
===========================================

You're probably using a combination of `go get` and an old Go version. The `go get` utility is programmed to look for tags matching the current Go version. Right now there's a tag for Go1.2.2 for instance, so if you haven't upgraded to Go1.3, `go get` will grab an older API. See the [API Changes](https://github.com/go-gl/mathgl#api-changes) section for details on the version tagging.

Contributing
============

Feel free to submit pull requests for features and bug fixes. Do note that, aside from documentation bugs, meta (travis.yml etc) fixes, example code, and *extremely* trivial changes (basic accessors) pull requests will not be accepted without tests corresponding to the new code. If it's a bug fix, the test should test the bug.

`mgl64` is generated directly from 32-bit version. To reflect your changes run `go generate github.com/go-gl/mathgl/mgl32` (or just `go generate` in `mgl32` directory). Also note that since code generation is used in `matrix.go` and `vector.go`, no changes should be made to those files directly. Edit `matrix.tmpl` or `vector.tmpl` and run go generate.

API Changes
===========

From now on, no major API breaking changes will be made between Go version releases. That means any time any "x" in Go1.x.x increases. Exceptions are made, of course, for bug fixes. If a bug fix necessitates changing semantics of calling software, it will be changed. (An example is the recent update of Transpose which was mistakenly using row major rules). Deprecated functions may also be nuked at major version released. Before any API breaking changes near major releases, the most recent non-breaking commit will be tagged with the previous Go version number (e.g. Go1.2.2). If no such tag exists, one can assume nothing has been broken.

API-Breaking changes made for latest Go release
-----------------------------------------------

Removal of EulerToQuat; use AnglesToQuat with the order ZYX instead.


mathgl

Go port of [glMatrix](https://glmatrix.net/) library

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  
[![Build Status](https://secure.travis-ci.org/technohippy/go-glmatrix.png?branch=master)](http://travis-ci.org/technohippy/go-glmatrix)
[![Coverage Status](https://coveralls.io/repos/technohippy/go-glmatrix/badge.svg?branch=master)](https://coveralls.io/r/technohippy/go-glmatrix?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/technohippy/go-glmatrix)](https://goreportcard.com/report/github.com/technohippy/go-glmatrix)
[![GoDoc](https://godoc.org/github.com/technohippy/go-glmatrix?status.svg)](https://godoc.org/github.com/technohippy/go-glmatrix)
[![license](https://img.shields.io/badge/license-MIT-4183c4.svg)](https://github.com/technohippy/go-glmatrix/blob/master/LICENSE.txt)

# go-glmatrix

go-glmatrix is a golang version of [glMatrix](http://glmatrix.net/), which is ``designed to perform vector and matrix operations stupidly fast''.

## Usage

```go
package main

import (
	"fmt"
	glm "github.com/technohippy/go-glmatrix"
)

func main() {
	// config
	rotateQuat := glm.QuatFromValues(1, 2, 3, 4)
	translateVec3 := glm.Vec3FromValues(1, 2, 3)
	scale := []float64{4, 5, 6}
	rotateOrigin := []float64{7, 8, 9}

	// construct matrix
	transMat := glm.Mat4Create()
	glm.Mat4Identity(transMat)
	glm.Mat4Translate(transMat, transMat, translateVec3)
	glm.Mat4Translate(transMat, transMat, rotateOrigin)
	rotateMat := glm.Mat4Create()
	rotateMat = glm.Mat4FromQuat(rotateMat, rotateQuat)
	matrix := glm.Mat4Multiply(glm.Mat4Create(), transMat, rotateMat)
	glm.Mat4Scale(matrix, matrix, scale)
	negativeOrigin := glm.Vec3Negate(glm.Vec3Create(), rotateOrigin)
	glm.Mat4Translate(matrix, matrix, negativeOrigin)

	// transform position
	position := glm.Vec3FromValues(10, 20, 30)
	glm.Vec3TransformMat4(position, position, matrix)
	fmt.Printf(glm.Vec3Str(position)) // => vec3(1280, -290, -42)
}
```

## Document

- See [https://pkg.go.dev/](https://pkg.go.dev/github.com/technohippy/go-glmatrix)
- or See [the documentation for glMatrix](http://glmatrix.net/docs/)

## License

MIT

go-glmatrix

Go cross-platform OpenGL bindings (OS X, Linux, Windows, browsers, iOS, Android)

gl
==

[![Go Reference](https://pkg.go.dev/badge/github.com/goxjs/gl.svg)](https://pkg.go.dev/github.com/goxjs/gl)

Package gl is a Go cross-platform binding for OpenGL, with an OpenGL ES 2-like API.

It supports:

- **macOS**, **Linux** and **Windows** via OpenGL 2.1 backend,

- **iOS** and **Android** via OpenGL ES 2.0 backend,

- **Modern Browsers** (desktop and mobile) via WebGL 1.0 backend.

This is a fork of golang.org/x/mobile/gl package with [CL 8793](https://go-review.googlesource.com/8793)
merged in and Windows support added. This package is fully functional, but may eventually become superceded by
the new x/mobile/gl plan. It will exist and be fully supported until it can be safely replaced by a better package.

Installation
------------

```sh
go get github.com/goxjs/gl
```

Usage
-----

This OpenGL binding has a ContextWatcher, which implements [glfw.ContextWatcher](https://godoc.org/github.com/goxjs/glfw#ContextWatcher)
interface. Recommended usage is with github.com/goxjs/glfw package, which accepts a ContextWatcher in its Init, and takes on the responsibility
of notifying it when context is made current or detached.

```Go
if err := glfw.Init(gl.ContextWatcher); err != nil {
	// Handle error.
}
defer glfw.Terminate()
```

If you're not using a ContextWatcher-aware glfw library, you must call methods of gl.ContextWatcher yourself whenever
you make a context current or detached.

```Go
window.MakeContextCurrent()
gl.ContextWatcher.OnMakeCurrent(nil)

glfw.DetachCurrentContext()
gl.ContextWatcher.OnDetach()
```

Directories
-----------

| Path                                                    | Synopsis                                            |
|---------------------------------------------------------|-----------------------------------------------------|
| [glutil](https://pkg.go.dev/github.com/goxjs/gl/glutil) | Package glutil implements OpenGL utility functions. |
| [test](https://pkg.go.dev/github.com/goxjs/gl/test)     | Package test contains tests for goxjs/gl.           |

License
-------

-	[BSD-style License](LICENSE)


goxjs/gl

Go cross-platform glfw library for creating an OpenGL context and receiving events

glfw
====

[![Go Reference](https://pkg.go.dev/badge/github.com/goxjs/glfw.svg)](https://pkg.go.dev/github.com/goxjs/glfw)

Package glfw experimentally provides a glfw-like API
with desktop (via glfw) and browser (via HTML5 canvas) backends.

It is used for creating a GL context and receiving events.

**Note:** This package is currently in development. The API is incomplete and may change.

Installation
------------

```sh
go get github.com/goxjs/glfw
```

Directories
-----------

| Path                                                                | Synopsis                                                           |
|---------------------------------------------------------------------|--------------------------------------------------------------------|
| [test/events](https://pkg.go.dev/github.com/goxjs/glfw/test/events) | events hooks every available callback and outputs their arguments. |

License
-------

-	[MIT License](LICENSE)


The Best Go Libraries For OpenGL (6)

gl

glfw

mathgl

go-glmatrix

goxjs/gl

goxjs/glfw