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 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() {
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()
}
}
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()
}
}
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 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() {
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()
}
}
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 (_ *NgLoop) onThreadWin() {
Stats.FrameWinThread.begin()
if glfw.PollEvents(); glfw.WindowParam(glfw.Opened) == 1 {
Loop.On.WinThread()
} else {
Loop.Running = false
}
Stats.FrameWinThread.end()
}
// Render renders the OpenGL backend.
func (e *Emu) Render() {
for glfw.WindowParam(glfw.Opened) != 0 {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.LoadIdentity()
e.disp.Render()
glfw.SwapBuffers()
}
}
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
}
}
func main() {
// This file holds the actual glyph shapes.
imgFile, err := gas.Abs("github.com/go-gl/examples/data/bitmap_font.png")
if err != nil {
log.Printf("Find font image file: %v", err)
return
}
// This file is a JSON encoded dataset which describes the font
// and contains the pixel offsets and sizes for each glyph in
// bitmap_font.png. Both files are needed to load a bitmap font.
configFile, err := gas.Abs("github.com/go-gl/examples/data/bitmap_font.js")
if err != nil {
log.Printf("Find font config file: %v", err)
return
}
err = initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
// Load the same bitmap font at different scale factors.
for i := range fonts {
fonts[i], err = loadFont(imgFile, configFile, i+1)
if err != nil {
log.Printf("LoadFont: %v", err)
return
}
defer fonts[i].Release()
}
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT)
err = drawString(10, 10, "0 1 2 3 4 5 6 7 8 9 A B C D E F")
if err != nil {
log.Printf("Printf: %v", err)
return
}
glfw.SwapBuffers()
}
}
func (v *Video) Loop() {
go func(c chan *Frame) {
for {
frame := <-c
v.frame = frame
}
}(v.Frames)
for glfw.WindowParam(glfw.Opened) == gl.TRUE {
if v.frame != nil {
v.Render(v.frame.Data, v.frame.Width, v.frame.Height)
}
runtime.Gosched()
}
glfw.Terminate()
}
func MainLoop() bool {
running = true
if nextScene != nil {
s := nextScene
nextScene = nil
LoadScene(s)
}
insideGameloop = true
if running && glfw.WindowParam(glfw.Opened) == 1 {
Run()
} else {
return false
}
insideGameloop = false
return true
}
func (rw *RenderWindow) Render() {
if glfw.WindowParam(glfw.Opened) == 0 {
close(rw.quit)
}
for i, c := range rw.Channels {
select {
case val := <-c.Buffer:
if int64(len(rw.renderBuffers[i])) > rw.Width {
rw.renderBuffers[i] = rw.renderBuffers[i][1:]
}
rw.renderBuffers[i] = append(rw.renderBuffers[i], val)
case <-rw.quit:
rw.Close()
default:
continue
}
}
rw.draw()
}
func main() {
err := initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
mb := createBuffer()
defer mb.Release()
// Perform the rendering.
var angle float32
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.LoadIdentity()
gl.Translatef(0, 0, -6)
gl.Rotatef(angle, 1, 1, 1)
// Render a solid cube at half the scale.
gl.Scalef(0.2, 0.2, 0.2)
gl.Enable(gl.COLOR_MATERIAL)
gl.Enable(gl.POLYGON_OFFSET_FILL)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
mb.Render(gl.QUADS)
// Render wireframe cubes, with incremental size.
gl.Disable(gl.COLOR_MATERIAL)
gl.Disable(gl.POLYGON_OFFSET_FILL)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
for i := 0; i < 50; i++ {
scale := 0.004*float32(i) + 1.0
gl.Scalef(scale, scale, scale)
mb.Render(gl.QUADS)
}
angle += 0.5
glfw.SwapBuffers()
}
}
func main() {
err := initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
// Create our texture atlas.
atlas := glh.NewTextureAtlas(AtlasSize, AtlasSize, 4)
defer atlas.Release()
// Fill the altas with image data.
fillAtlas(atlas)
// Display the atlas texture on a quad, so we can see
// what it looks like.
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT)
// Bind the atlas texture and render a quad with it.
atlas.Bind(gl.TEXTURE_2D)
gl.Begin(gl.QUADS)
gl.TexCoord2f(0, 0)
gl.Vertex2f(0, 0)
gl.TexCoord2f(1, 0)
gl.Vertex2f(AtlasSize, 0)
gl.TexCoord2f(1, 1)
gl.Vertex2f(AtlasSize, AtlasSize)
gl.TexCoord2f(0, 1)
gl.Vertex2f(0, AtlasSize)
gl.End()
atlas.Unbind(gl.TEXTURE_2D)
glfw.SwapBuffers()
}
}
func main() {
file, err := gas.Abs("code.google.com/p/freetype-go/luxi-fonts/luxisr.ttf")
if err != nil {
log.Printf("Find font file: %v", err)
return
}
err = initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
// Load the same font at different scale factors and directions.
for i := range fonts {
fonts[i], err = loadFont(file, int32(12+i))
if err != nil {
log.Printf("LoadFont: %v", err)
return
}
defer fonts[i].Release()
}
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT)
err = drawString(10, 10, SampleString)
if err != nil {
log.Printf("Printf: %v", err)
return
}
glfw.SwapBuffers()
}
}
func Run() {
running = true
for running {
start := time.Now()
escPressed := glfw.Key(glfw.KeyEsc)
windowOpen := glfw.WindowParam(glfw.Opened)
running = escPressed == 0 && windowOpen == 1
select {
case data := <-ScreenOutputChan:
drawFrame(data.Pixels)
drawInfoBox(3, 3, 12, data.IterNr, data.NThreads, data.ExecTime)
glfw.SwapBuffers()
default: // Non blocking!
glfw.PollEvents()
}
// Limit to 60hz
elapsed := time.Since(start)
timeToSleep := 16*time.Millisecond - elapsed
if timeToSleep > 0 {
time.Sleep(timeToSleep)
}
}
}
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
}
func main() {
err := initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
mb := createBuffer()
defer mb.Release()
attr := mb.Colors()
// Perform the rendering.
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.LoadIdentity()
// Center mesh on screen.
wx, wy := glfw.WindowSize()
px := (wx / 2) - ((Cols * CellWidth) / 2)
py := (wy / 2) - ((Rows * CellHeight) / 2)
gl.Translatef(float32(px), float32(py), 0)
// Change the color of the quad under the mouse cursor.
colorize(px, py, attr)
// Render the mesh.
mb.Render(gl.QUADS)
glfw.SwapBuffers()
}
attr = nil
}
func main() {
err := initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
defer glfw.Terminate()
mb := createBuffer()
defer mb.Release()
gl.Enable(gl.BLEND)
//gl.BlendFunc(gl.SRC_ALPHA, gl.ONE)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
f, err := os.Create("test.mpeg")
if err != nil {
log.Panicf("Unable to open output file: %q", err)
}
im := image.NewRGBA(image.Rect(0, 0, 512, 512))
e, err := ffmpeg.NewEncoder(ffmpeg.CODEC_ID_H264, im, f)
if err != nil {
log.Panicf("Unable to start encoder: %q", err)
}
// Perform the rendering.
var angle float64
for glfw.WindowParam(glfw.Opened) > 0 {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.LoadIdentity()
gl.Translatef(0, 0, -6)
gl.Rotated(angle/10, 0, 1, 0)
gl.Rotated(angle, 1, 1, 1)
// Render a solid cube at half the scale.
gl.Scalef(0.1, 0.1, 0.1)
gl.Enable(gl.COLOR_MATERIAL)
gl.Enable(gl.POLYGON_OFFSET_FILL)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
mb.Render(gl.QUADS)
// Render wireframe cubes, with incremental size.
gl.Disable(gl.COLOR_MATERIAL)
gl.Disable(gl.POLYGON_OFFSET_FILL)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
for i := 0; i < 1000; i++ {
ifl := float64(i)
scale := 0.000005*ifl + 1.0 + 0.01*math.Sin(angle/10+ifl/10)
gl.Scaled(scale, scale, scale)
gl.Rotated((ifl+angle)/1000, 1, 1, 1)
gl.Rotated((ifl+angle)/1100, -1, 1, 1)
mb.Render(gl.QUADS)
}
glh.ClearAlpha(1)
glh.CaptureRGBA(im)
err := e.WriteFrame()
if err != nil {
panic(err)
}
angle += 0.5
//glh.CaptureToPng("test.png")
glfw.SwapBuffers()
}
e.Close()
}
func main() {
flag.Parse()
loadMeshInfo()
err := initGL()
if err != nil {
log.Printf("InitGL: %v", err)
return
}
program, shaderInfo, err := loadShaders(gl.Program(0), nil)
if err != nil {
panic(err)
}
_ = program
defer glfw.Terminate()
mb := createBuffer()
defer mb.Release()
// Perform the rendering.
var angle float32
reload := time.Tick(time.Duration(300 * time.Millisecond))
for glfw.WindowParam(glfw.Opened) > 0 {
select {
case <-reload:
oldInfo := shaderInfo
program, shaderInfo, err = loadShaders(program, shaderInfo)
if err != nil && lastErr == nil {
lastErr = err
println("Error loading shaders. Using old code.", lastErr)
} else if err == nil && oldInfo != shaderInfo {
lastErr = nil
println("new shader code loaded")
}
default:
// do nothing here
}
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.LoadIdentity()
gl.Translatef(0, 0, -zoom)
if angle > 0 {
gl.Rotatef(angle, rotVet[0], rotVet[1], rotVet[2])
}
program.Use()
gl.Enable(gl.COLOR_MATERIAL)
gl.Enable(gl.POLYGON_OFFSET_FILL)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
mb.Render(gl.TRIANGLES)
if rotVet[0]+rotVet[1]+rotVet[2] != 0 {
// only increment the angle if at least one of the rotate axis
// is enabled
angle += 0.5
} else if angle != 0 {
angle = 0
}
glfw.SwapBuffers()
}
}
func main_loop(data *ProgramData) {
start := time.Now()
frames := 0
lastblocks := 0
// Frame counter
go func() {
for {
time.Sleep(time.Second)
if *verbose {
memstats := new(runtime.MemStats)
runtime.ReadMemStats(memstats)
fps := float64(frames) / time.Since(start).Seconds()
blocks := len(data.blocks)
bps := float64(blocks-lastblocks) / time.Since(start).Seconds()
lastblocks = blocks
log.Printf("fps = %5.2f; blocks = %4d; bps = %5.2f sparemem = %6d MB; alloc'd = %6.6f; (+footprint = %6.6f)",
fps, len(data.blocks), bps, SpareRAM(), float64(memstats.Alloc)/1024/1024,
float64(memstats.Sys-memstats.Alloc)/1024/1024)
PrintTimers(frames)
}
start = time.Now()
frames = 0
}
}()
// Necessary at the moment to prevent eventual OOM
go func() {
for {
time.Sleep(5 * time.Second)
if *verbose {
log.Print("GC()")
}
runtime.GC()
if *verbose {
GCStats()
}
}
}()
var i int64 = -int64(*nback)
// TODO(pwaller): Make this work again
// text := glh.MakeText(data.filename, 32)
// Location of mouse in record space
var rec, rec_actual int64 = 0, 0
var stacktext, dwarftext []*glh.Text
var recordtext *glh.Text = nil
var mousex, mousey, mousedownx, mousedowny int
var mousepx, mousepy float64
var lbutton bool
escape_hit := false
glfw.SetMouseWheelCallback(func(pos int) {
nback_prev := *nback
if pos < 0 {
*nback = 40 * 1024 << uint(-pos)
} else {
*nback = 40 * 1024 >> uint(pos)
}
//log.Print("Mousewheel position: ", pos, " nback: ", *nback)
if rec == 0 {
return
}
// mouse cursor is at screen "rec_actual", and it should be after
// the transformation
// We need to adjust `i` to keep this value constant:
// rec_actual == i + int64(constpart * float64(*nback))
// where constpart <- (-const + 2.) / 4.
// (that way, the mouse is still pointing at the same place after scaling)
constpart := float64(rec_actual-i) / float64(nback_prev)
rec_actual_after := i + int64(constpart*float64(*nback))
delta := rec_actual_after - rec_actual
i -= delta
// Ensure the mouse cursor position doesn't change when zooming
rec = rec_actual - i
})
update_text := func() {
if DoneThisFrame(RenderText) {
return
}
if recordtext != nil {
recordtext.Destroy()
recordtext = nil
}
//r := 0 //data.GetRecord(rec_actual)
//if r != nil {
//log.Print(data.records[rec_actual])
//recordtext = MakeText(r.String(), 32)
//}
for j := range stacktext {
stacktext[j].Destroy()
}
// TODO: Load records on demand
if false {
stack := data.GetStackNames(rec_actual)
stacktext = make([]*glh.Text, len(stack))
for j := range stack {
stacktext[j] = glh.MakeText(stack[j], 32)
}
}
}
glfw.SetMouseButtonCallback(func(button, action int) {
switch button {
case glfw.Mouse1:
switch action {
case glfw.KeyPress:
mousedownx, mousedowny = mousex, mousey
lbutton = true
r := data.GetRecord(rec_actual)
if r != nil {
if r.Type == MEMA_ACCESS {
log.Print(r)
ma := r.MemAccess()
dwarf := data.GetDwarf(ma.Pc)
log.Print("Can has dwarf? ", len(dwarf))
for i := range dwarf {
log.Print(" ", dwarf[i])
//recordtext = MakeText(data.records[rec_actual].String(), 32)
}
log.Print("")
for j := range dwarftext {
dwarftext[j].Destroy()
}
dwarftext = make([]*glh.Text, len(dwarf))
for j := range dwarf {
dwarftext[j] = glh.MakeText(fmt.Sprintf("%q", dwarf[j]), 32)
}
}
//recordtext = MakeText(data.records[rec_actual].String(), 32)
}
case glfw.KeyRelease:
lbutton = false
}
}
})
glfw.SetMousePosCallback(func(x, y int) {
px, py := glh.WindowToProj(x, y)
// Record index
rec = int64((py+2)*float64(*nback)/4. + 0.5)
rec_actual = rec + i
dpy := py - mousepy
di := int64(-dpy * float64(*nback) / 4.)
if lbutton {
i += di
}
mousepx, mousepy = px, py
mousex, mousey = x, y
//log.Printf("Mouse motion: (%3d, %3d), (%f, %f), (%d, %d) dpy=%f di=%d",
//x, y, px, py, rec, rec_actual, dpy, di)
update_text()
})
glfw.SetKeyCallback(func(key, state int) {
switch key {
case glfw.KeyEsc:
escape_hit = true
}
})
draw_mousepoint := func() {
// Draw the mouse point
glh.With(glh.Matrix{gl.MODELVIEW}, func() {
gl.Translated(0, -2, 0)
gl.Scaled(1, 4/float64(*nback), 1)
gl.Translated(0, float64(rec), 0)
gl.PointSize(10)
glh.With(glh.Primitive{gl.POINTS}, func() {
gl.Color4f(1, 1, 1, 1)
gl.Vertex3d(mousepx, 0, 0)
})
})
}
draw_text := func() {
// Draw any text
glh.With(glh.WindowCoords{}, func() {
w, h := glh.GetViewportWHD()
glh.With(glh.Attrib{gl.ENABLE_BIT}, func() {
gl.Enable(gl.TEXTURE_2D)
// text.Draw(0, 0)
for text_idx := range stacktext {
stacktext[text_idx].Draw(int(w*0.55), int(h)-35-text_idx*16)
}
for text_idx := range dwarftext {
dwarftext[text_idx].Draw(int(w*0.55), 35+text_idx*16)
}
if recordtext != nil {
recordtext.Draw(int(w*0.55), 35)
}
})
})
}
Draw = func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// Draw the memory access/function data
data.Draw(i, *nback)
draw_mousepoint()
draw_text()
// Visible region quad
// gl.Color4f(1, 1, 1, 0.25)
// DrawQuadd(-2.1, -2.25, 4.4, 2.1 - -2.25)
// StatsHUD()
}
interrupt := make(chan os.Signal)
signal.Notify(interrupt, os.Interrupt)
ctrlc_hit := false
go func() {
<-interrupt
ctrlc_hit = true
}()
done := false
for !done {
done_this_frame = make(map[WorkType]bool)
glh.With(&Timer{Name: "Draw"}, func() {
Draw()
})
glfw.SwapBuffers()
DoMainThreadWork()
done = ctrlc_hit || escape_hit || glfw.WindowParam(glfw.Opened) == 0
frames += 1
}
}
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.GlewExperimental(true)
gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked
gl.GetError() // ignore error, since we're telling it to use CoreProfile above, we get "invalid enumerant" (GLError 1280) which freaks the OpenGLSentinel out
// With go-gl we also apparently can't set glewExperimental
glfw.SetWindowTitle("Tutorial 05")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
Projection := mathgl.Perspective(45.0, 4.0/3.0, 0.1, 100.0)
View := mathgl.LookAt(4.0, 3.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
Model := mathgl.Ident4f()
MVP := Projection.Mul4(View).Mul4(Model) // Remember, transform multiplication order is "backwards"
texture := helper.MakeTextureFromTGA("uvtemplate.tga")
defer texture.Delete()
texSampler := prog.GetUniformLocation("myTextureSampler")
vBufferData := [...]float32{
-1.0, -1.0, -1.0,
-1.0, -1.0, 1.0,
-1.0, 1.0, 1.0,
1.0, 1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, -1.0,
1.0, -1.0, 1.0,
-1.0, -1.0, -1.0,
1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
1.0, -1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, 1.0,
-1.0, 1.0, -1.0,
1.0, -1.0, 1.0,
-1.0, -1.0, 1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, 1.0,
-1.0, -1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
1.0, -1.0, -1.0,
1.0, 1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, -1.0,
-1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0,
1.0, -1.0, 1.0}
uvBufferData := [...]float32{
0.000059, 1.0 - 0.000004,
0.000103, 1.0 - 0.336048,
0.335973, 1.0 - 0.335903,
1.000023, 1.0 - 0.000013,
0.667979, 1.0 - 0.335851,
0.999958, 1.0 - 0.336064,
0.667979, 1.0 - 0.335851,
0.336024, 1.0 - 0.671877,
0.667969, 1.0 - 0.671889,
1.000023, 1.0 - 0.000013,
0.668104, 1.0 - 0.000013,
0.667979, 1.0 - 0.335851,
0.000059, 1.0 - 0.000004,
0.335973, 1.0 - 0.335903,
0.336098, 1.0 - 0.000071,
0.667979, 1.0 - 0.335851,
0.335973, 1.0 - 0.335903,
0.336024, 1.0 - 0.671877,
1.000004, 1.0 - 0.671847,
0.999958, 1.0 - 0.336064,
0.667979, 1.0 - 0.335851,
0.668104, 1.0 - 0.000013,
0.335973, 1.0 - 0.335903,
0.667979, 1.0 - 0.335851,
0.335973, 1.0 - 0.335903,
0.668104, 1.0 - 0.000013,
0.336098, 1.0 - 0.000071,
0.000103, 1.0 - 0.336048,
0.000004, 1.0 - 0.671870,
0.336024, 1.0 - 0.671877,
0.000103, 1.0 - 0.336048,
0.336024, 1.0 - 0.671877,
0.335973, 1.0 - 0.335903,
0.667969, 1.0 - 0.671889,
1.000004, 1.0 - 0.671847,
0.667979, 1.0 - 0.335851}
vertexBuffer := gl.GenBuffer()
defer vertexBuffer.Delete()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW)
uvBuffer := gl.GenBuffer()
defer uvBuffer.Delete()
uvBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(uvBufferData)*4, &uvBufferData, 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) {
func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
prog.Use()
defer gl.ProgramUnuse()
matrixID.UniformMatrix4fv(false, MVP)
gl.ActiveTexture(gl.TEXTURE0)
texture.Bind(gl.TEXTURE_2D)
defer texture.Unbind(gl.TEXTURE_2D)
texSampler.Uniform1i(0)
vertexAttrib := gl.AttribLocation(0)
vertexAttrib.EnableArray()
defer vertexAttrib.DisableArray()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
defer vertexBuffer.Unbind(gl.ARRAY_BUFFER)
vertexAttrib.AttribPointer(3, gl.FLOAT, false, 0, nil)
uvAttrib := gl.AttribLocation(1)
uvAttrib.EnableArray()
defer uvAttrib.DisableArray()
uvBuffer.Bind(gl.ARRAY_BUFFER)
defer uvBuffer.Unbind(gl.ARRAY_BUFFER)
uvAttrib.AttribPointer(2, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, 12*3)
glfw.SwapBuffers()
}() // Defers unbinds and disables to here, end of the loop
}
}
func main() {
var err error
var looping = true
defer fmt.Println("EXIT")
if err = glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 0)
if useStrictCoreProfile {
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 2)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
}
if err = glfw.OpenWindow(1280, 720, 8, 8, 8, 0, 24, 8, glfw.Windowed); err != nil {
panic(err)
}
defer glfw.CloseWindow()
glfw.Enable(glfw.StickyKeys)
if !gl.Util.Init() {
panic("Failed to initialize at least OpenGL 3.2 or higher.")
}
defer logLastGlError("(post loop)")
gl.ClearColor(0.3, 0.1, 0.0, 1.0)
gl.Enable(gl.DEPTH_TEST)
gl.FrontFace(gl.CCW)
gl.CullFace(gl.BACK)
gl.Disable(gl.CULL_FACE)
if err = compileShaders(); err != nil {
panic(err)
}
setupGeometry()
defer deleteGeometry()
logLastGlError("(pre loop)")
for looping {
gl.UseProgram(shaderProg)
if isFirstLoop {
logLastGlError("gl.UseProgram")
}
gl.Viewport(0, 0, 1280, 720)
if isFirstLoop {
logLastGlError("gl.ViewPort")
}
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
if isFirstLoop {
logLastGlError("gl.Clear")
}
renderGeometry(faceTri)
if isFirstLoop {
logLastGlError("renderGeometry(faceTri)")
}
renderGeometry(faceQuad)
if isFirstLoop {
logLastGlError("renderGeometry(faceQuad)")
}
if (glfw.WindowParam(glfw.Opened) != 1) || (glfw.Key(glfw.KeyEsc) == glfw.KeyPress) {
looping = false
} else {
glfw.SwapBuffers()
}
isFirstLoop = false
}
logLastGlError("post-loop")
}
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
}
glfw.SetSwapInterval(0)
//gl.GlewExperimental(true)
gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked
gl.GetError() // ignore error, since we're telling it to use CoreProfile above, we get "invalid enumerant" (GLError 1280) which freaks the OpenGLSentinel out
glfw.SetWindowTitle("Tutorial 07")
glfw.Enable(glfw.StickyKeys)
glfw.Disable(glfw.MouseCursor) // Not in the original tutorial, but IMO it SHOULD be there
glfw.SetMousePos(1024.0/2.0, 768.0/2.0)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)
camera := input.NewCamera()
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
texture := helper.MakeTextureFromTGA("uvmap.tga") // Had to convert to tga, go-gl is missing the texture method for DDS right now
defer texture.Delete()
texSampler := prog.GetUniformLocation("myTextureSampler")
meshObj := objloader.LoadObject("cube.obj")
vertices, uvs := meshObj.Vertices, meshObj.UVs
vertexBuffer := gl.GenBuffer()
defer vertexBuffer.Delete()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*3*4, vertices, gl.STATIC_DRAW)
uvBuffer := gl.GenBuffer()
defer uvBuffer.Delete()
uvBuffer.Bind(gl.ARRAY_BUFFER)
// UV doesn't seem to care
gl.BufferData(gl.ARRAY_BUFFER, len(uvs)*2*4, uvs, 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 && glfw.Key('Q') != glfw.KeyPress) {
func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
prog.Use()
defer gl.ProgramUnuse()
view, proj := camera.ComputeViewPerspective()
model := mathgl.Ident4f()
MVP := proj.Mul4(view).Mul4(model)
matrixID.UniformMatrix4fv(false, MVP)
gl.ActiveTexture(gl.TEXTURE0)
texture.Bind(gl.TEXTURE_2D)
defer texture.Unbind(gl.TEXTURE_2D)
texSampler.Uniform1i(0)
vertexAttrib := gl.AttribLocation(0)
vertexAttrib.EnableArray()
defer vertexAttrib.DisableArray()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
defer vertexBuffer.Unbind(gl.ARRAY_BUFFER)
vertexAttrib.AttribPointer(3, gl.FLOAT, false, 0, nil)
uvAttrib := gl.AttribLocation(1)
uvAttrib.EnableArray()
defer uvAttrib.DisableArray()
uvBuffer.Bind(gl.ARRAY_BUFFER)
defer uvBuffer.Unbind(gl.ARRAY_BUFFER)
uvAttrib.AttribPointer(2, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, len(vertices))
glfw.SwapBuffers()
}() // Defers unbinds and disables to here, end of the loop
}
}
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 04")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
Projection := mathgl.Perspective(45.0, 4.0/3.0, 0.1, 100.0)
View := mathgl.LookAt(4.0, 3.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
Model := mathgl.Ident4f()
MVP := Projection.Mul4(View).Mul4(Model) // Remember, transform multiplication order is "backwards"
vBufferData := [...]float32{
-1.0, -1.0, -1.0,
-1.0, -1.0, 1.0,
-1.0, 1.0, 1.0,
1.0, 1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, -1.0,
1.0, -1.0, 1.0,
-1.0, -1.0, -1.0,
1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
1.0, -1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, 1.0,
-1.0, 1.0, -1.0,
1.0, -1.0, 1.0,
-1.0, -1.0, 1.0,
-1.0, -1.0, -1.0,
-1.0, 1.0, 1.0,
-1.0, -1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
1.0, -1.0, -1.0,
1.0, 1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, -1.0,
-1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0,
1.0, -1.0, 1.0}
colorBufferData := [...]float32{
0.583, 0.771, 0.014,
0.609, 0.115, 0.436,
0.327, 0.483, 0.844,
0.822, 0.569, 0.201,
0.435, 0.602, 0.223,
0.310, 0.747, 0.185,
0.597, 0.770, 0.761,
0.559, 0.436, 0.730,
0.359, 0.583, 0.152,
0.483, 0.596, 0.789,
0.559, 0.861, 0.639,
0.195, 0.548, 0.859,
0.014, 0.184, 0.576,
0.771, 0.328, 0.970,
0.406, 0.615, 0.116,
0.676, 0.977, 0.133,
0.971, 0.572, 0.833,
0.140, 0.616, 0.489,
0.997, 0.513, 0.064,
0.945, 0.719, 0.592,
0.543, 0.021, 0.978,
0.279, 0.317, 0.505,
0.167, 0.620, 0.077,
0.347, 0.857, 0.137,
0.055, 0.953, 0.042,
0.714, 0.505, 0.345,
0.783, 0.290, 0.734,
0.722, 0.645, 0.174,
0.302, 0.455, 0.848,
0.225, 0.587, 0.040,
0.517, 0.713, 0.338,
0.053, 0.959, 0.120,
0.393, 0.621, 0.362,
0.673, 0.211, 0.457,
0.820, 0.883, 0.371,
0.982, 0.099, 0.879}
//elBufferData := [...]uint8{0, 1, 2} // Not sure why this is here
vertexBuffer := gl.GenBuffer()
defer vertexBuffer.Delete()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW)
colorBuffer := gl.GenBuffer()
defer colorBuffer.Delete()
colorBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(colorBufferData)*4, &colorBufferData, 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 | gl.DEPTH_BUFFER_BIT)
prog.Use()
matrixID.UniformMatrix4fv(false, MVP)
vertexAttrib := gl.AttribLocation(0)
vertexAttrib.EnableArray()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
vertexAttrib.AttribPointer(3, gl.FLOAT, false, 0, nil)
colorAttrib := gl.AttribLocation(1)
colorAttrib.EnableArray()
colorBuffer.Bind(gl.ARRAY_BUFFER)
colorAttrib.AttribPointer(3, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, 12*3)
vertexAttrib.DisableArray()
colorAttrib.DisableArray()
glfw.SwapBuffers()
}
}
func New(width int, height int, title string) *Window {
var err error
window := &Window{width: width, height: height, title: title}
// initialize logger
logf, err := os.OpenFile("window.log", os.O_WRONLY|os.O_CREATE, 0640)
logger := log.New(logf, "", log.Ldate|log.Ltime)
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return nil
}
// width, hieght, r,g,b,a (color depth bits), depth, stencil, mode
if err = glfw.OpenWindow(window.width, window.height, 8, 8, 8, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return nil
}
onResize := func(w, h int) {
logger.Printf("resized: %dx%d\n", w, h)
}
onClose := func() int {
logger.Println("window closed\n")
return 1 // return 0 to keep window open.
}
// list callback generators
createBtnList := func(btnNext func() interface{}, device string) func(button, state int) {
btnList := list.New()
btnNext = func() interface{} { return btnList.Remove(btnList.Back()) }
return func(button, state int) {
btnList.PushFront(btnEvent{button: button, state: state})
logger.Printf("%s button: %d, %d\n", device, button, state)
}
}
createPosList := func(posNext func() interface{}, device string) func(x, y int) {
posList := list.New()
posNext = func() interface{} { return posList.Remove(posList.Back()) }
return func(x, y int) {
posList.PushFront(posEvent{x: x, y: y})
logger.Printf("%s pos: %d, %d\n", device, x, y)
}
}
createDeltaList := func(deltaNext func() interface{}, device string) func(delta int) {
deltaList := list.New()
deltaNext = func() interface{} { return deltaList.Remove(deltaList.Back()) }
return func(delta int) {
deltaList.PushFront(deltaEvent{delta: delta})
logger.Printf("%s delta: %d\n", device, delta)
}
}
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(title)
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMousePosCallback(createPosList(window.MousePos, "mouse pos"))
glfw.SetMouseButtonCallback(createBtnList(window.MouseBtn, "mouse"))
glfw.SetMouseWheelCallback(createDeltaList(window.MouseWheel, "mouse wheel"))
glfw.SetKeyCallback(createBtnList(window.KeyEvt, "keyboard"))
glfw.SetCharCallback(createBtnList(window.CharEvt, "char"))
window.Start = func() {
defer glfw.Terminate()
defer glfw.CloseWindow()
running := true
for running {
window.Render()
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
}
}
return window
}