func main() {
var err error
if err = glfw.Init(); err != nil { ///初始化环境
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate() /// 销毁环境
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { ///创建窗口
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow() /// 销毁窗口
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(Title) ///设置标题
glfw.SetWindowSizeCallback(onResize) /// 回调窗口变化
glfw.SetKeyCallback(onKey) ///回调按键
initGL()
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
drawScene()
}
}
// Initialize the window. Returns an error if glfw or glew throws one.
func InitWindow(width, height int) error {
Width, Height = width, height
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(Width, Height, 0, 0, 0, 32, 32, 32, glfw.Windowed)
if err != nil {
return err
}
WindowOpened = true
glfw.SetWindowTitle("Goliath")
glfw.Enable(glfw.KeyRepeat)
if ret := gl.Init(); ret != 0 {
return fmt.Errorf("failed to initialize GLEW: %d", ret)
}
// Set GL states
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Enable(gl.CULL_FACE)
gl.CullFace(gl.BACK)
gl.FrontFace(gl.CCW)
err = InitShaders()
if err != nil {
return err
}
InitCamera(Width, Height)
return nil
}
func main() {
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate()
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(Title)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
if err = initGL(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer destroyGL()
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
drawScene()
}
}
func main() {
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate()
if err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetWindowTitle("Draw")
glfw.SetSwapInterval(1)
glfw.SetKeyCallback(onKey)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetWindowSizeCallback(onResize)
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
if mouse[0] != 0 {
pen.lineTo(glfw.MousePos())
} else {
pen.moveTo(glfw.MousePos())
}
glfw.SwapBuffers()
}
}
// initGL initializes GLFW and OpenGL.
func initGL(c *cpu.CPU, width, height int) error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
err = glfw.OpenWindow(width, height, 8, 8, 8, 8, 8, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("DCPU")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
gl.Init()
err = glh.CheckGLError()
if err != nil {
return err
}
gl.Disable(gl.LIGHTING)
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0, 0, 0, 1)
return err
}
// Creates an initialized controller.
func NewController() (c *Controller, err error) {
if err = glfw.Init(); err != nil {
return
}
c = &Controller{}
return
}
func (me *context) Init() (err error) {
if err = glfw.Init(); err == nil {
glfw.Disable(glfw.StickyKeys)
glfw.Disable(glfw.AutoPollEvents)
}
return
}
func (i *IO) Init(title string, screenSize int, onCloseHandler func()) error {
var err error
err = glfw.Init()
if err != nil {
return err
}
err = i.Display.init(title, screenSize)
if err != nil {
return err
}
i.KeyHandler.Init(DefaultControlScheme) //TODO: allow user to define controlscheme
glfw.SetKeyCallback(func(key, state int) {
if state == glfw.KeyPress {
i.KeyHandler.KeyDown(key)
} else {
i.KeyHandler.KeyUp(key)
}
})
glfw.SetWindowCloseCallback(func() int {
glfw.CloseWindow()
glfw.Terminate()
onCloseHandler()
return 0
})
return nil
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("go-gl/gltext: Bitmap font example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
errno := gl.Init()
if errno != gl.NO_ERROR {
str, err := glu.ErrorString(errno)
if err != nil {
return fmt.Errorf("Unknown openGL error: %d", errno)
}
return fmt.Errorf(str)
}
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.LIGHTING)
gl.ClearColor(0.2, 0.2, 0.23, 0.0)
return nil
}
func (v *Video) Init(w int, h int) {
var err error
if err = glfw.Init(); err != nil {
log.Fatal(err)
}
glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE)
if err = glfw.OpenWindow(w, h, 8, 8, 8, 0, 24, 0, glfw.Windowed); err != nil {
log.Fatal(err)
}
if gl.Init() != 0 {
log.Fatal("ummm... hmmm")
}
glfw.SetWindowSizeCallback(resize)
gl.Enable(gl.TEXTURE_2D)
resize(w, h)
v.Texture = gl.GenTexture()
}
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
gl.Init()
gl.GetError() // Ignore error
glfw.SetWindowTitle("Tutorial 01")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
// Equivalent to a do... while
for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
glfw.SwapBuffers()
}
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Meshbuffer 2D example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.MULTISAMPLE)
gl.Disable(gl.LIGHTING)
gl.Enable(gl.COLOR_MATERIAL)
gl.ClearColor(0.2, 0.2, 0.23, 1.0)
return nil
}
func Init() {
runtime.LockOSThread()
// Initialize GLFW
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
err = glfw.OpenWindow(SCREEN_WIDTH, SCREEN_HEIGHT,
0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Fatalf("%v\n", err)
return
}
glfw.SetWindowTitle("Mandelbrot")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetMouseWheelCallback(onMouseWheel)
glfw.SetKeyCallback(onKey)
glfw.SetCharCallback(onChar)
// Initialize OpenGL
gl.Disable(gl.DEPTH_TEST)
gl.ClearColor(0, 0, 0, 0)
}
func make_window(w, h int, title string) func() {
// Required to make sure that the OpenGL go-routine doesn't get switched
// to another thread (=> kerblammo)
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
log.Panic("glfw Error:", err)
}
err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Panic("Error:", err)
}
if gl.Init() != 0 {
log.Panic("gl error")
}
if *vsync {
glfw.SetSwapInterval(1)
} else {
glfw.SetSwapInterval(0)
}
glfw.SetWindowTitle(title)
glfw.SetWindowSizeCallback(Reshape)
Init()
return func() {
glfw.Terminate()
glfw.CloseWindow()
log.Print("Cleanup")
}
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(AtlasSize, AtlasSize, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Texture atlas example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.LIGHTING)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0.2, 0.2, 0.23, 1.0)
return nil
}
func RunGame(title string, width, height int, init, draw func()) {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "glfw: %s\n", err)
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
if err := glfw.OpenWindow(width, height, 0, 0, 0, 0, 16, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "glfw: %s\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(title)
if err := gl.Init(); err != nil {
fmt.Fprintf(os.Stderr, "gl: %s\n", err)
}
if err := initScene(width, height, init); err != nil {
fmt.Fprintf(os.Stderr, "init: %s\n", err)
return
}
// defer destroyScene()
for glfw.WindowParam(glfw.Opened) == 1 {
drawScene(draw)
glfw.SwapBuffers()
}
}
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
defer glfw.Terminate()
if err := glfw.OpenWindow(appWidth, appHeight, 8, 8, 8, 8, 24, 8, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
defer glfw.CloseWindow()
if err := gl.Init(); err != 0 {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
glfw.SetWindowTitle(title)
fps := fps.NewFPS(glfw.Time())
blocks.Init(appWidth, appHeight)
for glfw.WindowParam(glfw.Opened) == 1 {
blocks.Tick()
fps.Tick(glfw.Time())
if glfw.WindowParam(glfw.Active) == 1 {
glfw.Sleep(0.001)
} else {
glfw.Sleep(0.05)
}
}
}
func init() {
go func() {
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
log.Panic("glfw Error:", err)
}
w, h := 100, 100
err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Panic("Error:", err)
}
if gl.Init() != 0 {
log.Panic("gl error")
}
glfw.SetWindowSizeCallback(Reshape)
glfw.SwapBuffers()
for {
(<-main_thread_setup)()
glfw.SwapBuffers()
(<-main_thread_after)()
main_thread_work_done <- true
}
}()
}
func (i *IO) Init(title string, screenSize int, onCloseHandler func()) error {
i.KeyHandler = new(KeyHandler)
i.Display = new(Display)
i.ScreenOutputChannel = make(chan *types.Screen)
i.AudioOutputChannel = make(chan int)
if err := glfw.Init(); err != nil {
return err
} else if err = i.Display.init(title, screenSize); err != nil {
return err
}
i.KeyHandler.Init(DefaultControlScheme) //TODO: allow user to define controlscheme
glfw.SetKeyCallback(func(key, state int) {
if state == glfw.KeyPress {
i.KeyHandler.KeyDown(key)
} else {
i.KeyHandler.KeyUp(key)
}
})
glfw.SetWindowCloseCallback(func() int {
glfw.CloseWindow()
glfw.Terminate()
onCloseHandler()
return 0
})
return nil
}
func StartEngine() {
runtime.GOMAXPROCS(runtime.NumCPU())
runtime.LockOSThread()
fmt.Println("Enginge started!")
var err error
if err = glfw.Init(); err != nil {
panic(err)
}
fmt.Println("GLFW Initialized!")
glfw.OpenWindowHint(glfw.Accelerated, 1)
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 8, 8, glfw.Windowed); err != nil {
panic(err)
}
glfw.SetSwapInterval(1) //0 to disable vsync, 1 to enable it
glfw.SetWindowTitle(windowTitle)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(input.OnKey)
glfw.SetCharCallback(input.OnChar)
glfw.SetMouseButtonCallback(input.ButtonPress)
glfw.SetMouseWheel(0)
glfw.SetMouseWheelCallback(input.MouseWheelCallback)
input.MouseWheelPosition = glfw.MouseWheel
input.MousePosition = glfw.MousePos
if err = initGL(); err != nil {
panic(err)
}
fmt.Println("Opengl Initialized!")
TextureMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader)
err = TextureMaterial.Load()
if err != nil {
fmt.Println(err)
}
SDFMaterial = NewBasicMaterial(sdfVertexShader, sdfFragmentShader)
err = SDFMaterial.Load()
if err != nil {
fmt.Println(err)
}
internalMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader)
err = internalMaterial.Load()
if err != nil {
fmt.Println(err)
}
initDefaultPlane()
glfw.SwapBuffers()
gameTime = time.Time{}
lastTime = time.Now()
dl = glfw.Time()
}
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked
gl.GetError() // Ignore error
glfw.SetWindowTitle("Tutorial 02")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
prog := helper.MakeProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader")
vBufferData := [...]float32{
-1., -1., 0.,
1., -1., 0.,
0., 1., 0.}
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
buffer := gl.GenBuffer()
buffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW)
// Equivalent to a do... while
for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
gl.Clear(gl.COLOR_BUFFER_BIT)
prog.Use()
attribLoc := gl.AttribLocation(0)
attribLoc.EnableArray()
buffer.Bind(gl.ARRAY_BUFFER)
attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
attribLoc.DisableArray()
glfw.SwapBuffers()
}
}
func main() {
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate()
// Open window with FSAA samples (if possible).
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
if err = glfw.OpenWindow(400, 400, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetWindowTitle("Aliasing Detector")
glfw.SetSwapInterval(1)
if samples := glfw.WindowParam(glfw.FsaaSamples); samples != 0 {
fmt.Printf("Context reports FSAA is supported with %d samples\n", samples)
} else {
fmt.Printf("Context reports FSAA is unsupported\n")
}
gl.MatrixMode(gl.PROJECTION)
glu.Perspective(0, 1, 0, 1)
for glfw.WindowParam(glfw.Opened) == 1 {
time := float32(glfw.Time())
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.LoadIdentity()
gl.Translatef(0.5, 0, 0)
gl.Rotatef(time, 0, 0, 1)
gl.Enable(GL_MULTISAMPLE_ARB)
gl.Color3f(1, 1, 1)
gl.Rectf(-0.25, -0.25, 0.25, 0.25)
gl.LoadIdentity()
gl.Translatef(-0.5, 0, 0)
gl.Rotatef(time, 0, 0, 1)
gl.Disable(GL_MULTISAMPLE_ARB)
gl.Color3f(1, 1, 1)
gl.Rectf(-0.25, -0.25, 0.25, 0.25)
glfw.SwapBuffers()
}
}
func main() {
fmt.Print("GLFW Init Start.")
glfw.Init()
fmt.Println(" GLFW Init Done.")
defer glfw.Terminate()
defer fmt.Println("example Terminating.")
fmt.Println("GLFW Set Hints.")
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
fmt.Print("GLFW Open Window Start.")
glfw.OpenWindow(640, 480, 8, 8, 8, 0, 0, 0, glfw.Windowed)
glfw.SetWindowTitle("example")
fmt.Println(" GLFW Open Window Done.")
v1, v2, v3 := glfw.GLVersion()
fmt.Printf("OpenGL version: %d.%d.%d\n", v1, v2, v3)
fmt.Printf("GLFW version: %d.%d.%d\n", glfw.VersionMajor, glfw.VersionMinor, glfw.VersionRevision)
glfw.SetSwapInterval(1)
fps := time.Duration(30)
fmt.Printf("Creating %d Hz Ticker.", fps)
ticker := time.NewTicker(time.Second / fps)
fmt.Printf(" %d Hz Ticker Created\n", fps)
closedWindow := glfwHelper.WindowCloseChan()
mouseButtons := glfwHelper.MouseButtonChan()
mousePos := glfwHelper.MousePosChan()
mouseWheel := glfwHelper.MouseWheelChan()
keyButtons := glfwHelper.KeyChan()
charButtons := glfwHelper.CharChan()
for {
select {
case <-ticker.C:
glfw.SwapBuffers()
case <-closedWindow:
return
case input := <-mouseButtons:
fmt.Println(input)
case input := <-mousePos:
fmt.Println(input)
case input := <-mouseWheel:
fmt.Println(input)
case input := <-keyButtons:
fmt.Println(input)
case input := <-charButtons:
fmt.Println(string(input))
}
}
}
func NewRenderWindow(title string, width, height int, quit chan struct{}) (*RenderWindow, error) {
rw := new(RenderWindow)
rw.Title = title
rw.Width = int64(width)
rw.Height = int64(height)
rw.quit = quit
rw.renderBuffers = make([][]int64, 0)
err := glfw.Init()
if err != nil {
return nil, err
}
return rw, nil
}
func (s *System) Startup() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
// glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
// glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 2)
// glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
InitQueue()
}
func Test(t *testing.T) {
err := glfw.Init()
if err != nil {
t.Fatal(err)
}
defer glfw.Terminate()
err = glfw.OpenWindow(800, 600, 8, 8, 8, 0, 0, 0, glfw.Windowed)
if err != nil {
t.Fatal(err)
}
defer glfw.CloseWindow()
kb := New()
kb.Bind(func() {
fmt.Println("pressed s")
}, "s")
kb.Bind(func() {
fmt.Println("pressed ctrl+s or command+s")
}, "ctrl+s", "command+s")
kb.Bind(func() {
fmt.Println("pressed 't e s t'")
}, "t e s t")
kb.Bind(func() {
fmt.Println("pressed '3'")
}, "3")
kb.Bind(func() {
fmt.Println("pressed '#'")
}, "#")
kb.Bind(func() {
glfw.CloseWindow()
}, "escape")
// Print available keybindings.
fmt.Printf("Known key bindings:\n")
for _, b := range kb.Bindings() {
fmt.Printf(" - %q\n", b)
}
// Go into GLFW's main event loop.
for glfw.WindowParam(glfw.Opened) == 1 {
glfw.SwapBuffers()
}
}
func main() {
var err error
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
// Ensure glfw is cleanly terminated on exit.
defer glfw.Terminate()
if err = glfw.OpenWindow(256, 256, 8, 8, 8, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
// Ensure window is cleanly closed on exit.
defer glfw.CloseWindow()
// Enable vertical sync on cards that support it.
glfw.SetSwapInterval(1)
// Set window title
glfw.SetWindowTitle("Simple GLFW window")
// Hook some events to demonstrate use of callbacks.
// These are not necessary if you don't need them.
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetMouseWheelCallback(onMouseWheel)
glfw.SetKeyCallback(onKey)
glfw.SetCharCallback(onChar)
// Start loop
running := true
for running {
// OpenGL rendering goes here.
// Swap front and back rendering buffers. This also implicitly calls
// glfw.PollEvents(), so we have valid key/mouse/joystick states after
// this. This behavior can be disabled by calling glfw.Disable with the
// argument glfw.AutoPollEvents. You must be sure to manually call
// PollEvents() or WaitEvents() in this case.
glfw.SwapBuffers()
// Break out of loop when Escape key is pressed, or window is closed.
running = glfw.Key(glfw.KeyEsc) == 0 && glfw.WindowParam(glfw.Opened) == 1
}
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE)
err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 32, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Meshbuffer 3D example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.MULTISAMPLE)
gl.Disable(gl.LIGHTING)
//gl.ClearColor(0.2, 0.2, 0.23, 1.0)
gl.ClearColor(0, 0, 0, 1.0)
gl.ShadeModel(gl.SMOOTH)
gl.LineWidth(2)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
gl.ColorMaterial(gl.FRONT_AND_BACK, gl.AMBIENT_AND_DIFFUSE)
return nil
}
func (_ *NgUserIO) init(forceContextVersion float64) (err error) {
UserIO.KeyToggleMinDelay, UserIO.lastToggles = 0.15, make(map[int]float64, 80)
if !UserIO.isGlfwInit {
if err = glfw.Init(); err == nil {
UserIO.isGlfwInit = true
}
}
if UserIO.isGlfwInit && !UserIO.Window.isCreated {
glfw.OpenWindowHint(glfw.FsaaSamples, 0) // AA will be a pluggable post-processing shader
if forceContextVersion > 0 {
major, minor := ugl.VersionMajorMinor(forceContextVersion)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, major)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, minor)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if Options.Initialization.GlContext.CoreProfile.ForwardCompat {
glfw.OpenWindowHint(glfw.OpenGLForwardCompat, 1)
}
}
err = UserIO.recreateWin()
}
return
}
func (v *video) init() error {
// Disclaimer: I'm an absolute noob in openGL and I just slammed the
// keyboard with my text editor open, until it started to produce usable
// results. I don't fully understand everything I'm doing here.
if err := glfw.Init(); err != nil {
return err
}
err := glfw.OpenWindow(screenWidth*pixelSize, screenHeight*pixelSize, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
return err
}
// Enable vertical sync on cards that support it.
glfw.SetSwapInterval(1)
glfw.SetWindowTitle("nictuku's CHIP-8 emulator")
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.ClearColor(0, 0, 0, 0)
gl.MatrixMode(gl.PROJECTION)
// Change coordinates to range from [0, 64] and [0,32].
gl.Ortho(0, screenWidth, screenHeight, 0, 0, 1)
// Unnecessary sanity check. :-P
if glfw.WindowParam(glfw.Opened) == 0 {
return fmt.Errorf("No window opened")
}
return nil
}