func SetVSync(enabled bool) {
vsync = enabled
if vsync {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
}
func init() {
renderVSync.Callback(func() {
if glfw.GetCurrentContext() == nil {
return
}
if renderVSync.Value() {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
})
}
func Init() {
runtime.LockOSThread()
err := glfw.Init()
if err != nil {
panic(fmt.Sprintf("glfw.Init() fails: %v", err))
}
glfw.WindowHint(glfw.Visible, glfw.False)
glfw.WindowHint(glfw.Resizable, glfw.False)
// As start, create an window with temporary size to create OpenGL context thread.
window, err := glfw.CreateWindow(16, 16, "", nil, nil)
if err != nil {
panic(err)
}
u := &userInterface{
window: window,
funcs: make(chan func()),
}
go func() {
runtime.LockOSThread()
u.window.MakeContextCurrent()
glfw.SwapInterval(1)
for f := range u.funcs {
f()
}
}()
currentUI = u
}
func main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
w, err := glfw.CreateWindow(640, 480, "Testing", nil, nil)
if err != nil {
panic(err)
}
w.MakeContextCurrent()
glfw.SwapInterval(1)
w.SetCharCallback(charCallBack)
if err := gl.Init(); err != nil {
panic(err)
}
setupScene(w)
fmt.Println("Press 'q' to quit")
for !w.ShouldClose() {
// Do OpenGL stuff.
time.Sleep(10 * time.Millisecond)
drawScene(w)
w.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
w, err := glfw.CreateWindow(640, 480, "Testing 3+", nil, nil)
if err != nil {
panic(err)
}
w.MakeContextCurrent()
glfw.SwapInterval(1)
w.SetCharCallback(charCallBack)
if err := gl.Init(); err != nil {
panic(err)
}
r := makeResources()
gl.ClearColor(.5, .5, .5, 0)
fmt.Println("Press 'q' to quit")
for !w.ShouldClose() {
time.Sleep(10 * time.Millisecond)
render(w, r)
w.SwapBuffers()
glfw.PollEvents()
}
}
// InitGraphics creates an OpenGL window and initializes the required graphics libraries.
// It will either succeed or panic.
func (app *ExampleApp) InitGraphics(title string, w int, h int) {
err := glfw.Init()
if err != nil {
panic("Can't init glfw! " + err.Error())
}
// request a OpenGL 3.3 core context
glfw.WindowHint(glfw.Samples, 0)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
// do the actual window creation
app.MainWindow, err = glfw.CreateWindow(w, h, title, nil, nil)
if err != nil {
panic("Failed to create the main window! " + err.Error())
}
app.MainWindow.MakeContextCurrent()
glfw.SwapInterval(0)
// make sure that all of the GL functions are initialized
err = gl.Init()
if err != nil {
panic("Failed to initialize GL! " + err.Error())
}
// set the app window dimensions
app.Width = w
app.Height = h
gl.FrontFace(gl.CCW)
gl.CullFace(gl.BACK)
gl.Enable(gl.CULL_FACE)
}
func main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
width, height = 800, 800
window, err := glfw.CreateWindow(width, height, "Show RoundedRect", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
window.SetSizeCallback(reshape)
window.SetKeyCallback(onKey)
window.SetCharCallback(onChar)
glfw.SwapInterval(1)
err = gl.Init()
if err != nil {
panic(err)
}
reshape(window, width, height)
for !window.ShouldClose() {
if redraw {
display()
window.SwapBuffers()
redraw = false
}
glfw.PollEvents()
// time.Sleep(2 * time.Second)
}
}
func main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Resizable, glfw.True)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
window, err := glfw.CreateWindow(640, 480, "Testing", nil, nil)
if err != nil {
panic(err)
}
defer window.Destroy()
window.MakeContextCurrent()
glfw.SwapInterval(1)
window.SetSizeCallback(func(w *glfw.Window, width int, height int) {
fmt.Printf("resize: %d, %d\n", width, height)
gl.Viewport(0, 0, int32(width), int32(height))
})
window.SetCursorPosCallback(func(w *glfw.Window, xpos float64, ypos float64) {
fmt.Printf("mouse: %f, %f\n", xpos, ypos)
})
window.SetFocusCallback(func(w *glfw.Window, focused bool) {
fmt.Printf("focus: %t\n", focused)
})
window.SetKeyCallback(func(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
if key == glfw.KeyEscape {
window.SetShouldClose(true)
}
fmt.Printf("key\n")
})
window.SetMouseButtonCallback(func(w *glfw.Window, button glfw.MouseButton, action glfw.Action, mod glfw.ModifierKey) {
fmt.Printf("mouse\n")
})
window.SetCharCallback(func(w *glfw.Window, char rune) {
fmt.Printf("char: '%c'\n", char)
})
if err := gl.Init(); err != nil {
panic(err)
}
for !window.ShouldClose() {
draw()
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
window, err := glfw.CreateWindow(800, 600, "fontstash example", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
glfw.SwapInterval(1)
gl.Init()
data, err := ioutil.ReadFile(filepath.Join("..", "ClearSans-Regular.ttf"))
if err != nil {
panic(err)
}
gl.Enable(gl.TEXTURE_2D)
tmpBitmap := make([]byte, 512*512)
cdata, err, _, tmpBitmap := truetype.BakeFontBitmap(data, 0, 32, tmpBitmap, 512, 512, 32, 96)
var ftex uint32
gl.GenTextures(1, &ftex)
gl.BindTexture(gl.TEXTURE_2D, ftex)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.ALPHA, 512, 512, 0,
gl.ALPHA, gl.UNSIGNED_BYTE, unsafe.Pointer(&tmpBitmap[0]))
gl.ClearColor(0.3, 0.3, 0.32, 1.)
for !window.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, 800, 600, 0, 0, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Disable(gl.DEPTH_TEST)
gl.Color4ub(255, 255, 255, 255)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
my_print(100, 100, "The quick brown fox jumps over the fence", ftex, cdata)
window.SwapBuffers()
glfw.PollEvents()
}
}
// createWindow initializes the graphics libraries and creates the main window for the game.
// it pulls the settings for the window from the options structure passed in.
func createWindow(options *Options) (*glfw.Window, error) {
// GLFW must be initialized before it's called
err := glfw.Init()
if err != nil {
return nil, fmt.Errorf("Can't init glfw! %v", err)
}
// request a OpenGL 3.3 core context
glfw.WindowHint(glfw.Samples, 0)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
// do the actual window creation
mainWindow, err := glfw.CreateWindow(options.WindowWidth, options.WindowHeight, appWindowName, nil, nil)
if err != nil {
return nil, fmt.Errorf("Failed to create the main window! %v", err)
}
mainWindow.MakeContextCurrent()
// set vsync options
if options.VSyncEnabled {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
// make sure that all of the GL functions are initialized
err = gl.Init()
if err != nil {
return nil, fmt.Errorf("Can't init gl! %v", err)
}
// write out the gl version for debug purposes
version := gl.GoStr(gl.GetString(gl.VERSION))
groggy.Log("INFO", "OpenGL version ", version)
return mainWindow, nil
}
func startWindow() {
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
glfw.WindowHint(glfw.DepthBits, 32)
glfw.WindowHint(glfw.StencilBits, 0)
if os.Getenv("STEVEN_DEBUG") == "true" {
glfw.WindowHint(glfw.OpenGLDebugContext, glfw.True)
}
var err error
window, err = glfw.CreateWindow(854, 480, "Steven", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
if renderVSync.Value() {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
window.SetCursorPosCallback(onMouseMove)
window.SetMouseButtonCallback(onMouseClick)
window.SetKeyCallback(onKey)
window.SetCharCallback(onChar)
window.SetScrollCallback(onScroll)
window.SetFocusCallback(onFocus)
gl.Init()
start()
for !window.ShouldClose() {
draw()
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
runtime.LockOSThread()
// initialize glfw
if err := glfw.Init(); err != nil {
log.Fatalln("Failed to initialize GLFW: ", err)
}
defer glfw.Terminate()
// create window
window, err := glfw.CreateWindow(1280, 720, os.Args[0], nil, nil)
if err != nil {
log.Fatal(err)
}
window.SetFramebufferSizeCallback(onResize)
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
log.Fatal(err)
}
// set up opengl context
onResize(window, 600, 600)
// player = createPlayer()
// addBall()
// set up physics
game = engine.NewGame()
game.Init()
game.ReadLevelFromFile("level.json")
//Init Controlls I think
// glfw.KeyCallback(window)
window.SetKeyCallback(keyCallback)
runtime.LockOSThread()
glfw.SwapInterval(1)
ticker := time.NewTicker(time.Second / 60)
for !window.ShouldClose() {
game.Update(1.0 / 60.0)
draw()
window.SwapBuffers()
glfw.PollEvents()
<-ticker.C // wait up to 1/60th of a second
}
}
func main() {
runtime.LockOSThread()
// initialize glfw
if err := glfw.Init(); err != nil {
log.Fatalln("Failed to initialize GLFW: ", err)
}
defer glfw.Terminate()
// create window
window, err := glfw.CreateWindow(600, 600, os.Args[0], nil, nil)
if err != nil {
log.Fatal(err)
}
window.SetFramebufferSizeCallback(onResize)
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
log.Fatal(err)
}
// set up opengl context
onResize(window, 600, 600)
// set up physics
createBodies()
runtime.LockOSThread()
glfw.SwapInterval(1)
ticksToNextBall := 10
ticker := time.NewTicker(time.Second / 60)
for !window.ShouldClose() {
ticksToNextBall--
if ticksToNextBall == 0 {
ticksToNextBall = rand.Intn(100) + 1
addBall()
}
draw()
step(1.0 / 60.0)
window.SwapBuffers()
glfw.PollEvents()
<-ticker.C // wait up to 1/60th of a second
}
}
func initialize() (*opengl.Context, error) {
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
return nil, err
}
glfw.WindowHint(glfw.Visible, glfw.False)
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
// As start, create an window with temporary size to create OpenGL context thread.
window, err := glfw.CreateWindow(16, 16, "", nil, nil)
if err != nil {
return nil, err
}
u := &userInterface{
window: window,
funcs: make(chan func()),
sizeChanged: true,
}
ch := make(chan error)
go func() {
runtime.LockOSThread()
u.window.MakeContextCurrent()
glfw.SwapInterval(1)
var err error
u.context, err = opengl.NewContext()
if err != nil {
ch <- err
}
close(ch)
u.context.Loop()
}()
currentUI = u
if err := <-ch; err != nil {
return nil, err
}
if err := u.context.Init(); err != nil {
return nil, err
}
return u.context, nil
}
func main() {
runtime.LockOSThread()
// initialize glfw
if err := glfw.Init(); err != nil {
log.Fatalln("Failed to initialize GLFW: ", err)
}
defer glfw.Terminate()
// create window
window, err := glfw.CreateWindow(1280, 720, os.Args[0], nil, nil)
if err != nil {
log.Fatal(err)
}
window.SetFramebufferSizeCallback(onResize)
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
log.Fatal(err)
}
// set up opengl context
onResize(window, 1280, 720)
// glfw.KeyCallback(window)
window.SetKeyCallback(keyCallback)
runtime.LockOSThread()
glfw.SwapInterval(1)
player = NewBall(600, 600)
ticker := time.NewTicker(time.Second / 60)
for !window.ShouldClose() {
player.update()
//Output
draw()
window.SwapBuffers()
glfw.PollEvents()
<-ticker.C // wait up to 1/60th of a second
}
}
func (c *Context) CreateWindow(w, h int, name string) (err error) {
c.w = w
c.h = h
c.name = name
c.createWindow()
c.SetCursor(c.cursor)
gl.Init()
if e := gl.GetError(); e != 0 {
if e != gl.INVALID_ENUM {
err = fmt.Errorf("OpenGL glInit error: %X\n", e)
return
}
}
c.OpenGLVersion = glfw.GetVersionString()
c.ShaderVersion = gl.GoStr(gl.GetString(gl.SHADING_LANGUAGE_VERSION))
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Disable(gl.CULL_FACE)
glfw.SwapInterval(1)
return
}
func (c *Context) CreateWindow(w, h int, name string) (err error) {
c.w = w
c.h = h
c.name = name
var monitor *glfw.Monitor
if c.fullscreen == true {
monitor = glfw.GetPrimaryMonitor()
}
if c.window, err = glfw.CreateWindow(c.w, c.h, c.name, monitor, nil); err != nil {
return
}
if c.cursor == false {
c.window.SetInputMode(glfw.CursorMode, glfw.CursorHidden)
}
c.window.MakeContextCurrent()
gl.Init()
if e := gl.GetError(); e != 0 {
if e == gl.INVALID_ENUM {
fmt.Printf("GL_INVALID_ENUM when calling glInit\n")
} else {
err = fmt.Errorf("OpenGL glInit error: %X\n", e)
return
}
}
c.OpenGLVersion = glfw.GetVersionString()
c.ShaderVersion = gl.GoStr(gl.GetString(gl.SHADING_LANGUAGE_VERSION))
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Disable(gl.CULL_FACE)
glfw.SwapInterval(1)
if c.VAO, err = CreateVAO(); err != nil {
return
}
gl.BindVertexArray(c.VAO)
c.Events = NewEventHandler(c.window)
return
}
func CreateWindow(title string, width int, height int) *Window {
if err := glfw.Init(); err != nil {
log.Fatalln("Failed to initialize glfw:", err)
}
/* GLFW Window settings */
glfw.WindowHint(glfw.ContextVersionMajor, 4)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, title, nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
glfw.SwapInterval(2)
/* Initialize OpenGL */
if err := gl.Init(); err != nil {
panic(err)
}
window.SetInputMode(glfw.CursorMode, glfw.CursorDisabled)
window.SetKeyCallback(KeyCallback)
window.SetCursorPosCallback(MouseMoveCallback)
window.SetMouseButtonCallback(MouseButtonCallback)
w := &Window{
Width: width,
Height: height,
Wnd: window,
maxFrameTime: 0.0,
lastFrameTime: glfw.GetTime(),
}
w.SetMaxFps(60)
return w
}
func main() {
src, err := os.OpenFile("tiger.ps", 0, 0)
if err != nil {
log.Println("can't find postscript file.")
return
}
defer src.Close()
bytes, err := ioutil.ReadAll(src)
postscriptContent = string(bytes)
err = glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
window, err = glfw.CreateWindow(800, 800, "Show Tiger in OpenGL", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
window.SetSizeCallback(reshape)
window.SetKeyCallback(onKey)
glfw.SwapInterval(1)
err = gl.Init()
if err != nil {
panic(err)
}
reshape(window, 800, 800)
for !window.ShouldClose() {
display()
window.SwapBuffers()
glfw.PollEvents()
// time.Sleep(2 * time.Second)
}
}
func main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Resizable, glfw.False)
w, err := glfw.CreateWindow(400, 300, "Hello World", nil, nil)
if err != nil {
panic(err)
}
w.MakeContextCurrent()
glfw.SwapInterval(1)
w.SetCharCallback(charCallBack)
if err := gl.Init(); err != nil {
panic(err)
}
r := makeResources()
gl.ClearColor(1, 1, 1, 0)
fmt.Println("Press 'q' to quit")
for !w.ShouldClose() {
time.Sleep(10 * time.Millisecond)
updateFadeFactor(r)
render(w, r)
w.SwapBuffers()
glfw.PollEvents()
}
}
func InitDisplay(title string) error {
defer tlog.FuncLog(tlog.Func("InitDisplay"))
runtime.LockOSThread()
err := glfw.Init()
if err != nil {
return err
}
monitor := glfw.GetPrimaryMonitor()
mode := monitor.GetVideoMode()
tlog.Println("monitor mode", mode)
if DEBUG {
glfw.WindowHint(glfw.OpenGLDebugContext, gl.TRUE)
}
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLForwardCompatible, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
window, err = glfw.CreateWindow(mode.Width, mode.Height, title, nil, nil)
if err != nil {
return err
}
window.SetKeyCallback(onKey)
// glfw.SetMouseButtonCallback(onMouseBtn)
window.MakeContextCurrent()
glfw.SwapInterval(1)
return nil
}
func main() {
if err := glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 8) // Anti-aliasing.
window, err := glfw.CreateWindow(400, 400, "", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
panic(err)
}
glfw.SwapInterval(1)
//window.SetPos(50, 600)
//window.SetPos(1600, 600)
//window.SetPos(1275, 300)
//window.SetPos(1200, 300)
framebufferSizeCallback := func(w *glfw.Window, framebufferSize0, framebufferSize1 int) {
gl.Viewport(0, 0, int32(framebufferSize0), int32(framebufferSize1))
var windowSize [2]int
windowSize[0], windowSize[1] = w.GetSize()
// Update the projection matrix.
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(windowSize[0]), float64(windowSize[1]), 0, -1, 1)
gl.MatrixMode(gl.MODELVIEW)
}
{
var framebufferSize [2]int
framebufferSize[0], framebufferSize[1] = window.GetFramebufferSize()
framebufferSizeCallback(window, framebufferSize[0], framebufferSize[1])
}
window.SetFramebufferSizeCallback(framebufferSizeCallback)
go func() {
<-time.After(5 * time.Second)
log.Println("trigger!")
boxUpdated = true
glfw.PostEmptyEvent()
}()
//gl.ClearColor(0.8, 0.3, 0.01, 1)
gl.ClearColor(247.0/255, 247.0/255, 247.0/255, 1)
var spinner int
for !window.ShouldClose() && glfw.Press != window.GetKey(glfw.KeyEscape) {
glfw.WaitEvents()
//glfw.PollEvents()
gl.Clear(gl.COLOR_BUFFER_BIT)
drawSpinner(spinner)
spinner++
drawBox()
window.SwapBuffers()
log.Println("swapped buffers")
//runtime.Gosched()
}
}
func run(customGame CustomGame, title string, width, height int, fullscreen bool) {
err := glfw.Init()
fatalErr(err)
defer glfw.Terminate()
Arrow = glfw.CreateStandardCursor(int(glfw.ArrowCursor))
Hand = glfw.CreateStandardCursor(int(glfw.HandCursor))
monitor := glfw.GetPrimaryMonitor()
mode := monitor.GetVideoMode()
if fullscreen {
width = mode.Width
height = mode.Height
glfw.WindowHint(glfw.Decorated, 0)
} else {
monitor = nil
}
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
window, err = glfw.CreateWindow(width, height, title, nil, nil)
fatalErr(err)
window.MakeContextCurrent()
if !fullscreen {
window.SetPos((mode.Width-width)/2, (mode.Height-height)/2)
}
width, height = window.GetFramebufferSize()
glfw.SwapInterval(1)
Gl = webgl.NewContext()
Gl.Viewport(0, 0, width, height)
window.SetFramebufferSizeCallback(func(window *glfw.Window, w, h int) {
width, height = window.GetFramebufferSize()
Gl.Viewport(0, 0, width, height)
// TODO: when do we want to handle resizing? and who should deal with it?
// responder.Resize(w, h)
})
window.SetCursorPosCallback(func(window *glfw.Window, x, y float64) {
Mouse.X, Mouse.Y = float32(x), float32(y)
Mouse.Action = MOVE
})
window.SetMouseButtonCallback(func(window *glfw.Window, b glfw.MouseButton, a glfw.Action, m glfw.ModifierKey) {
x, y := window.GetCursorPos()
Mouse.X, Mouse.Y = float32(x), float32(y)
if a == glfw.Press {
Mouse.Action = PRESS
} else {
Mouse.Action = RELEASE
}
})
window.SetScrollCallback(func(window *glfw.Window, xoff, yoff float64) {
Mouse.ScrollX = float32(xoff)
Mouse.ScrollY = float32(yoff)
})
window.SetKeyCallback(func(window *glfw.Window, k glfw.Key, s int, a glfw.Action, m glfw.ModifierKey) {
key := Key(k)
if a == glfw.Press {
keyStates[key] = true
} else if a == glfw.Release {
keyStates[key] = false
}
})
window.SetCharCallback(func(window *glfw.Window, char rune) {
// TODO: what does this do, when can we use it?
// it's like KeyCallback, but for specific characters instead of keys...?
// responder.Type(char)
})
runLoop(customGame, false)
}
func main() {
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
window, err := glfw.CreateWindow(800, 600, "fontstash example", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
glfw.SwapInterval(1)
gl.Init()
stash := fontstash.New(512, 512)
clearSansRegular, err := stash.AddFont(filepath.Join("..", "ClearSans-Regular.ttf"))
if err != nil {
panic(err)
}
clearSansItalic, err := stash.AddFont(filepath.Join("..", "ClearSans-Italic.ttf"))
if err != nil {
panic(err)
}
clearSansBold, err := stash.AddFont(filepath.Join("..", "ClearSans-Bold.ttf"))
if err != nil {
panic(err)
}
droidJapanese, err := stash.AddFont(filepath.Join("..", "DroidSansJapanese.ttf"))
if err != nil {
panic(err)
}
gl.ClearColor(0.3, 0.3, 0.32, 1.)
for !window.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, 800, 0, 600, -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Disable(gl.DEPTH_TEST)
gl.Color4ub(255, 255, 255, 255)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Disable(gl.TEXTURE_2D)
gl.Begin(gl.QUADS)
gl.Vertex2i(0, -5)
gl.Vertex2i(5, -5)
gl.Vertex2i(5, -11)
gl.Vertex2i(0, -11)
gl.End()
sx := float64(100)
sy := float64(250)
stash.BeginDraw()
dx := sx
dy := sy
dx = stash.DrawText(clearSansRegular, 24, dx, dy, "The quick ", [4]float32{0, 0, 0, 1})
dx = stash.DrawText(clearSansItalic, 48, dx, dy, "brown ", [4]float32{1, 1, 0.5, 1})
dx = stash.DrawText(clearSansRegular, 24, dx, dy, "fox ", [4]float32{0, 1, 0.5, 1})
_, _, lh := stash.VMetrics(clearSansItalic, 24)
dx = sx
dy -= lh * 1.2
dx = stash.DrawText(clearSansItalic, 24, dx, dy, "jumps over ", [4]float32{0, 1, 1, 1})
dx = stash.DrawText(clearSansBold, 24, dx, dy, "the lazy ", [4]float32{1, 0, 1, 1})
dx = stash.DrawText(clearSansRegular, 24, dx, dy, "dog.", [4]float32{0, 1, 0, 1})
dx = sx
dy -= lh * 1.2
dx = stash.DrawText(clearSansRegular, 12, dx, dy, "Now is the time for all good men to come to the aid of the party.", [4]float32{0, 0, 1, 1})
_, _, lh = stash.VMetrics(clearSansItalic, 12)
dx = sx
dy -= lh * 1.2 * 2
dx = stash.DrawText(clearSansItalic, 18, dx, dy, "Ég get etið gler án þess að meiða mig.", [4]float32{1, 0, 0, 1})
_, _, lh = stash.VMetrics(clearSansItalic, 18)
dx = sx
dy -= lh * 1.2
stash.DrawText(droidJapanese, 18, dx, dy, "どこかに置き忘れた、サングラスと打ち明け話。", [4]float32{1, 1, 1, 1})
stash.EndDraw()
gl.Enable(gl.DEPTH_TEST)
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
glfw.SetErrorCallback(errorCallback)
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
setWindowHints()
window, err := glfw.CreateWindow(winWidth, winHeight, "Flappy Bird", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
// set up physics
initPhysics()
defer space.Destroy()
// create the flappy bird
addFlappy()
runtime.LockOSThread()
glfw.SwapInterval(1)
// set up opengl context
initOpenGl(window, winWidth, winHeight)
// init glut
initGlut()
// Hook mouse and key events
window.SetMouseButtonCallback(onMouseBtn)
window.SetKeyCallback(onKey)
window.SetCloseCallback(onClose)
ticksToNextPipe := 10
ticker := time.NewTicker(time.Second / 60)
// keep updating till we die ..
for !window.ShouldClose() {
// add pipe every 1.5 sec
ticksToNextPipe--
if ticksToNextPipe == 0 {
if !birdCollided {
ticksToNextPipe = 90
addPipe()
noOfPipesAdded++
// increment score
if noOfPipesAdded > 2 {
score++
}
} else {
ticksToNextPipe = 10
}
}
// render the display
render()
step(1.0 / 60.0)
window.SwapBuffers()
glfw.PollEvents()
<-ticker.C // wait up to 1/60th of a second
}
}
func main() {
runtime.LockOSThread()
rand.Seed(time.Now().UnixNano())
// initialize glfw
if err := glfw.Init(); err != nil {
log.Fatalln("Failed to initialize GLFW: ", err)
}
defer glfw.Terminate()
// create window
window, err := glfw.CreateWindow(600, 600, os.Args[0], nil, nil)
if err != nil {
log.Fatal(err)
}
window.SetFramebufferSizeCallback(onResize)
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
log.Fatal(err)
}
// set up opengl context
onResize(window, 600, 600)
// set up physics
createBodies()
glfw.SwapInterval(1)
phase := 0
ticker := time.NewTicker(time.Second / 60)
for !window.ShouldClose() {
switch phase {
case 0:
pos := getRandomPointInCircle(100.0)
w := vect.Float(roundm(float64(rand.Intn(28)+8.0), 4.0) * 2.0)
h := vect.Float(roundm(float64(rand.Intn(28)+8.0), 4.0) * 2.0)
addRoom(pos, w, h)
if len(rooms) > 50 {
phase = 1
fmt.Println("phase1")
}
case 1:
setRoomToSpace()
phase = 2
fmt.Println("phase2")
case 2:
step(1.0 / 60.0)
if waitForSleep() {
phase = 3
fmt.Println("phase3")
}
case 3:
}
draw(window)
window.SwapBuffers()
glfw.PollEvents()
<-ticker.C // wait up to 1/60th of a second
}
}
func (c *Context) SetSwapInterval(val int) {
glfw.SwapInterval(val)
}
func run(title string, width, height int, fullscreen bool) {
defer runtime.UnlockOSThread()
runtime.GOMAXPROCS(runtime.NumCPU())
fatalErr(glfw.Init())
monitor := glfw.GetPrimaryMonitor()
mode := monitor.GetVideoMode()
// ideally we want a "windowless full screen"
// but using normal full screen and disabling minimizing on OS X (which is broken)
// is the best we can do for now...
if fullscreen {
if runtime.GOOS == "darwin" {
glfw.WindowHint(glfw.AutoIconify, glfw.False)
}
glfw.WindowHint(glfw.Decorated, glfw.False)
} else {
monitor = nil
}
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
var err error
window, err = glfw.CreateWindow(width, height, title, monitor, nil)
fatalErr(err)
window.MakeContextCurrent()
if !fullscreen {
window.SetPos((mode.Width-width)/2, (mode.Height-height)/2)
}
width, height = window.GetFramebufferSize()
glfw.SwapInterval(1)
gl = webgl.NewContext()
gl.Viewport(0, 0, width, height)
window.SetFramebufferSizeCallback(func(window *glfw.Window, w, h int) {
width, height = window.GetFramebufferSize()
gl.Viewport(0, 0, width, height)
responder.Resize(w, h)
})
window.SetCursorPosCallback(func(window *glfw.Window, x, y float64) {
responder.Mouse(float32(x), float32(y), MouseMove, MOVE)
})
window.SetMouseButtonCallback(func(window *glfw.Window, b glfw.MouseButton, a glfw.Action, m glfw.ModifierKey) {
x, y := window.GetCursorPos()
if a == glfw.Press {
responder.Mouse(float32(x), float32(y), MouseKey(b), PRESS)
} else {
responder.Mouse(float32(x), float32(y), MouseKey(b), RELEASE)
}
})
window.SetScrollCallback(func(window *glfw.Window, xoff, yoff float64) {
responder.Scroll(float32(yoff))
})
window.SetKeyCallback(func(window *glfw.Window, k glfw.Key, s int, a glfw.Action, m glfw.ModifierKey) {
if a == glfw.Press {
responder.Key(Key(k), Modifier(m), PRESS)
} else if a == glfw.Release {
responder.Key(Key(k), Modifier(m), RELEASE)
}
})
window.SetCharCallback(func(window *glfw.Window, char rune) {
responder.Type(char)
})
setupAudio()
responder.Preload()
Files.Load(func() {})
responder.Setup()
shouldClose := window.ShouldClose()
for !shouldClose {
responder.Update(Time.Delta())
gl.Clear(gl.COLOR_BUFFER_BIT)
responder.Render()
window.SwapBuffers()
glfw.PollEvents()
Time.Tick()
shouldClose = window.ShouldClose()
}
window.Destroy()
glfw.Terminate()
responder.Close()
}
func main() {
fmt.Printf(`WolfenGo v%s, Copyright (C) 2016 gdm85
https://github.com/gdm85/wolfengo
WolfenGo comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under GNU/GPLv2 license.`+"\n", version)
if err := glfw.Init(); err != nil {
fatalError(err)
}
defer glfw.Terminate()
// create a context and activate it
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.DoubleBuffer, glfw.True)
var err error
Window, err = glfw.CreateWindow(800, 600, "WolfenGo", nil, nil)
if err != nil {
fatalError(err)
}
Window.MakeContextCurrent()
// gl.Init() should be called after context is current
if err := gl.Init(); err != nil {
fatalError(err)
}
glfw.SwapInterval(1) // enable vertical refresh
fmt.Println(gl.GoStr(gl.GetString(gl.VERSION)))
if debugGL {
gl.DebugMessageCallback(debugCb, unsafe.Pointer(nil))
gl.Enable(gl.DEBUG_OUTPUT)
}
// init graphics
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.FrontFace(gl.CW)
gl.CullFace(gl.BACK)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.DEPTH_CLAMP)
gl.Enable(gl.TEXTURE_2D)
isRunning := false
// load all assets
_, err = getBasicShader()
if err != nil {
fatalError(err)
}
err = _defaultMedkit.initMedkit()
if err != nil {
fatalError(err)
}
err = _defaultMonster.initMonster()
if err != nil {
fatalError(err)
}
getDoorMesh()
initPlayer()
err = initGun()
if err != nil {
fatalError(err)
}
G, err = NewGame()
if err != nil {
fatalError(err)
}
// GAME STARTS
isRunning = true
var frames uint64
var frameCounter time.Duration
frameTime := time.Duration(1000/frameCap) * time.Millisecond
lastTime := time.Now()
var unprocessedTime time.Duration
for isRunning {
var render bool
startTime := time.Now()
passedTime := startTime.Sub(lastTime)
lastTime = startTime
unprocessedTime += passedTime
frameCounter += passedTime
for unprocessedTime > frameTime {
render = true
unprocessedTime -= frameTime
if Window.ShouldClose() {
isRunning = false
}
G.timeDelta = frameTime.Seconds()
glfw.PollEvents()
err := G.input()
if err != nil {
fatalError(err)
}
err = G.update()
if err != nil {
fatalError(err)
}
if frameCounter >= time.Second {
if printFPS {
fmt.Printf("%d FPS\n", frames)
}
frames = 0
frameCounter -= time.Second
}
}
if render {
//TODO: Stencil Buffer
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
G.render()
frames++
Window.SwapBuffers()
} else {
time.Sleep(time.Millisecond)
}
}
Window.Destroy()
}
