func main() {
// Initialize GLFW for window management
glfw.SetErrorCallback(glfwErrorCallback)
if !glfw.Init() {
panic("failed to initialize glfw")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // Necessary for OS X
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile) // Necessary for OS X
glfw.WindowHint(glfw.OpenglDebugContext, glfw.True)
window, err := glfw.CreateWindow(WindowWidth, WindowHeight, "Cube", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// Initialize Glow
if err := gl.Init(); err != nil {
panic(err)
}
// Note that it is possible to use GL functions spanning multiple versions
if err := gl4.Init(); err != nil {
fmt.Printf("Could not initialize GL 4.4 (non-fatal)")
}
if gl.ARB_debug_output {
gl.Enable(gl.DEBUG_OUTPUT_SYNCHRONOUS_ARB)
gl.DebugMessageCallbackARB(gl.DebugProc(glDebugCallback), gl.Ptr(nil))
// Trigger an error to demonstrate debug output
gl.Enable(gl.CONTEXT_FLAGS)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
fmt.Println("OpenGL version", version)
// Configure the vertex and fragment shaders
program, err := newProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
gl.UseProgram(program)
projection := mgl32.Perspective(70.0, float32(WindowWidth)/WindowHeight, 0.1, 10.0)
projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00"))
gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0])
camera := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0})
cameraUniform := gl.GetUniformLocation(program, gl.Str("camera\x00"))
gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0])
model := mgl32.Ident4()
modelUniform := gl.GetUniformLocation(program, gl.Str("model\x00"))
gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00"))
gl.Uniform1i(textureUniform, 0)
gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00"))
// Load the texture
texture, err := newTexture("square.png")
if err != nil {
panic(err)
}
// Configure the vertex data
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(cubeVertices)*4, gl.Ptr(cubeVertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
texCoordAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texCoordAttrib)
gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
// Configure global settings
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
angle := 0.0
previousTime := glfw.GetTime()
for !window.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// Update
time := glfw.GetTime()
elapsed := time - previousTime
previousTime = time
angle += elapsed
model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0})
// Render
gl.UseProgram(program)
gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
gl.BindVertexArray(vao)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, texture)
gl.DrawArrays(gl.TRIANGLES, 0, 6*2*3)
// Maintenance
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 1", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
gl.ClearColor(0., 0., 0.4, 0.)
// Equivalent to a do... while
for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
window.SwapBuffers()
glfw.PollEvents()
}
}
// Initialize creates new window
func (e *E) Initialize(title string, params Params, state State) error {
if !glfw3.Init() {
return fmt.Errorf("unable to initialize glfw")
}
if e.window != nil {
return fmt.Errorf("Initialize error: window is not nil")
}
glfw3.SetErrorCallback(OnError)
glfw3.WindowHint(glfw3.Resizable, glfw3.True)
glfw3.WindowHint(glfw3.ContextVersionMajor, params.Version[0])
glfw3.WindowHint(glfw3.ContextVersionMinor, params.Version[1])
glfw3.WindowHint(glfw3.OpenglProfile, glfw3.OpenglCoreProfile)
glfw3.WindowHint(glfw3.OpenglDebugContext, glfw3.True)
size := params.Size
window, err := glfw3.CreateWindow(size[0], size[1], title, nil, nil)
if err != nil {
return err
}
window.MakeContextCurrent()
window.SetKeyCallback(e.OnKey)
window.SetFramebufferSizeCallback(e.OnFramebufferResize)
e.window = window
e.state = state
return nil
}
func main() {
glfw.SetErrorCallback(glfwErrorCallback)
if !glfw.Init() {
panic("failed to initialize glfw")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
window, err := glfw.CreateWindow(800, 600, "Cube", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
panic(err)
}
texture = newTexture("square.png")
defer gl.DeleteTextures(1, &texture)
setupScene()
for !window.ShouldClose() {
drawScene()
window.SwapBuffers()
glfw.PollEvents()
}
}
func RunIn3DContext(example func()) {
if !glfw.Init() {
log.Panic("glfw Error")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
w, h := 100, 100
window, err := glfw.CreateWindow(w, h, "Test", nil, nil)
if err != nil {
log.Panic(err)
}
window.MakeContextCurrent()
if gl.Init() != 0 {
log.Panic("gl error")
}
gl.GetError()
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
example()
}
func main() {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
defer glfw.Terminate()
gorgasm.Verbose = true
if !glfw.Init() {
panic("Can't init glfw!")
}
// Enable OpenGL ES 2.0.
glfw.WindowHint(glfw.ClientApi, glfw.OpenglEsApi)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
window, err := glfw.CreateWindow(testlib.Width, testlib.Height, "Gorgasm Test", nil, nil)
if err != nil {
panic(err)
}
gorgasm.Init(window)
go prettytest.Run(new(testing.T), testlib.NewTestSuite())
for !window.ShouldClose() {
glfw.WaitEvents()
}
}
func main() {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
defer glfw.Terminate()
mandala.Verbose = true
if !glfw.Init() {
panic("Can't init glfw!")
}
// Enable OpenGL ES 2.0.
glfw.WindowHint(glfw.ClientApi, glfw.OpenglEsApi)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
window, err := glfw.CreateWindow(Width, Height, "gltext black-box testing", nil, nil)
if err != nil {
panic(err)
}
glfw.SwapInterval(0)
mandala.Init(window)
go prettytest.Run(new(testing.T), testlib.NewTestSuite(outputPath))
for !window.ShouldClose() {
glfw.WaitEvents()
}
}
func setupGlfw() {
glfw.SetErrorCallback(onGlfwError)
glfw.WindowHint(glfw.Resizable, 1)
glfw.WindowHint(glfw.Visible, 1)
glfw.WindowHint(glfw.Decorated, 1)
glfw.WindowHint(glfw.ClientApi, glfw.OpenglApi)
glfw.WindowHint(glfw.OpenglForwardCompatible, 1)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglDebugContext, 1)
}
func initWindow() (window *glfw.Window, err error) {
monitor, err := glfw.GetPrimaryMonitor()
if err != nil {
return nil, err
}
videomode, err := monitor.GetVideoMode()
if err != nil {
return nil, err
}
if videomode.Height < 480 || videomode.Width < 640 {
return nil, errors.New("unsupported resolution!")
}
ratio := float64(videomode.Width) / float64(videomode.Height)
if fullscreen {
glfw.WindowHint(glfw.Decorated, 0)
window, err = glfw.CreateWindow(videomode.Width, videomode.Height, "Golang Asteroids!", nil, nil)
if err != nil {
return nil, err
}
window.SetPosition(0, 0)
} else {
glfw.WindowHint(glfw.Decorated, 1)
window, err = glfw.CreateWindow(int(ratio*480), 480, "Golang Asteroids!", nil, nil)
if err != nil {
return nil, err
}
window.SetPosition(videomode.Width/2-320, videomode.Height/2-240)
}
window.SetKeyCallback(keyCallback)
window.SetFramebufferSizeCallback(reshapeWindow)
window.MakeContextCurrent()
gl.Init()
gl.ClearColor(gl.GLclampf(Colorize(0)), gl.GLclampf(Colorize(0)), gl.GLclampf(Colorize(0)), 0.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
width, height := window.GetFramebufferSize()
reshapeWindow(window, width, height)
return window, nil
}
func main() {
flag.Parse()
glfw.SetErrorCallback(errorCallback)
if !glfw.Init() {
println("glfw init failure")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.ClientApi, glfw.OpenglEsApi)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 0)
window, err := glfw.CreateWindow(Width, Height, Title, nil, nil)
if err != nil {
panic(err)
}
defer window.Destroy()
window.MakeContextCurrent()
glfw.SwapInterval(1)
window.SetSizeCallback(reshape)
window.SetKeyCallback(keyEvent)
gl.Viewport(0, 0, Width, Height)
initScene()
if *debug {
go func() {
tick := time.Tick(1 * time.Second)
for {
<-tick
fmt.Printf("FPS:%v\tGOROUTINE:%v\r", atomic.LoadUint64(fps), runtime.NumGoroutine())
atomic.StoreUint64(fps, 0)
}
}()
}
for !window.ShouldClose() {
drawScene()
window.SwapBuffers()
glfw.PollEvents()
atomic.AddUint64(fps, 1)
}
}
func (self *OpenGLWindow) Open() {
var err error
if !glfw.Init() {
panic(errors.New("Unable to initialize GLFW"))
}
glfw.SetErrorCallback(func(code glfw.ErrorCode, desc string) {
log.Printf("[GLFW Error] (%d) %s", code, desc)
})
var monitor *glfw.Monitor
if self.config.Fullscreen {
monitor, err = glfw.GetPrimaryMonitor()
if err != nil {
panic(err)
}
}
glfw.WindowHint(glfw.ContextVersionMajor, 4)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
// Default buffer sizes
glfw.WindowHint(glfw.DepthBits, 32)
glfw.WindowHint(glfw.StencilBits, 0)
// Toggle VSync. Turning VSync off aparently doesn't work via glfw through
// some ATI cards and drivers
if self.config.VSync {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
self.window, err = glfw.CreateWindow(
int(self.config.Width), int(self.config.Height),
"Project Slartibartfast",
monitor,
nil)
if err != nil {
panic(err)
}
self.window.MakeContextCurrent()
if glewError := gl.Init(); glewError != 0 {
panic(errors.New("Unable to initialize OpenGL"))
}
}
func (a *Application) init() {
glfw.SetErrorCallback(a.glfwError)
if !glfw.Init() {
os.Exit(1)
}
a.Width = 1280
a.Height = 720
a.Title = filepath.Base(os.Args[0])
// For now, force a fixed size window. bgfx currently breaks glfw
// events on OS X because it overrides the NSWindow's content view.
glfw.WindowHint(glfw.Resizable, 0)
var err error
a.window, err = glfw.CreateWindow(a.Width, a.Height, a.Title, nil, nil)
if err != nil {
log.Fatalln(err)
}
bgfx_glfw.SetWindow(a.window)
}
func main() {
if !glfw.Init() {
panic("Failed to initialize GLFW")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.DepthBits, 16)
window, err := glfw.CreateWindow(300, 300, "Gears", nil, nil)
if err != nil {
panic(err)
}
// Set callback functions
window.SetFramebufferSizeCallback(reshape)
window.SetKeyCallback(key)
window.MakeContextCurrent()
glfw.SwapInterval(1)
width, height := window.GetFramebufferSize()
reshape(window, width, height)
// Parse command-line options
Init()
// Main loop
for !window.ShouldClose() {
// Draw gears
draw()
// Update animation
animate()
// Swap buffers
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
glfw.SetErrorCallback(errorCallback)
if !glfw.Init() {
panic("Can't init glfw!")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.DepthBits, 16)
window, err := glfw.CreateWindow(Width, Height, Title, nil, nil)
if err != nil {
panic(err)
}
window.SetFramebufferSizeCallback(reshape)
window.SetKeyCallback(key)
window.MakeContextCurrent()
glfw.SwapInterval(1000 / 60)
width, height := window.GetFramebufferSize()
reshape(window, width, height)
if err := initGL(); err != nil {
fmt.Fprintf(os.Stderr, "init: %s\n", err)
return
}
defer destroyGL()
for !window.ShouldClose() {
drawScene()
window.SwapBuffers()
glfw.PollEvents()
}
}
func CreateWindow(width, height int, name string, fullscreen bool, delegate WindowDelegate, legacy bool) error {
if !glfw.Init() {
return errors.New("Failed to initialize GLFW")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.DepthBits, 16)
if !legacy {
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, 1)
}
var monitor *glfw.Monitor = nil
var err error = nil
if fullscreen {
monitor, err = glfw.GetPrimaryMonitor()
if err != nil {
return err
}
vidModes, _ := monitor.GetVideoModes()
maxResolution := vidModes[len(vidModes)-1]
width = maxResolution.Width
height = maxResolution.Height
}
window, err := glfw.CreateWindow(width, height, name, monitor, nil)
if err != nil {
return err
}
if fullscreen {
window.SetInputMode(glfw.Cursor, glfw.CursorDisabled)
}
start := time.Now()
last := start
doSimulation := func() {
now := time.Now()
gameTime := GameTime{
now,
now.Sub(start),
now.Sub(last),
}
delegate.Simulate(gameTime)
last = now
}
bindEvents(window, &IdleSimulatorWindowDelegator{
WindowDelegator{delegate},
doSimulation,
})
window.MakeContextCurrent()
glfw.SwapInterval(1)
delegate.Init(window)
frameWidth, frameHeight := window.GetFramebufferSize()
delegate.Reshape(window, frameWidth, frameHeight)
for !window.ShouldClose() {
doSimulation()
if delegate.NeedsRender() {
delegate.Draw(window)
}
window.SwapBuffers()
if delegate.IsIdle() {
glfw.WaitEvents()
} else {
glfw.PollEvents()
}
}
return nil
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 8", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
window.SetCursorPosition(1024/2, 768/2)
window.SetInputMode(glfw.Cursor, glfw.CursorHidden)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)
camera := input.NewCamera(window)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("StandardShading.vertexshader", "StandardShading.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
viewMatrixID := prog.GetUniformLocation("V")
modelMatrixID := prog.GetUniformLocation("M")
texture, err := helper.TextureFromDDS("uvmap.DDS")
if err != nil {
fmt.Printf("Could not load texture: %v\n", err)
}
defer texture.Delete()
texSampler := prog.GetUniformLocation("myTextureSampler")
meshObj := objloader.LoadObject("suzanne.obj", true)
indices, indexedVertices, indexedUVs, indexedNormals := indexer.IndexVBOSlow(meshObj.Vertices, meshObj.UVs, meshObj.Normals)
vertexBuffer := gl.GenBuffer()
defer vertexBuffer.Delete()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(indexedVertices)*3*4, indexedVertices, gl.STATIC_DRAW)
uvBuffer := gl.GenBuffer()
defer uvBuffer.Delete()
uvBuffer.Bind(gl.ARRAY_BUFFER)
// And yet, the weird length stuff doesn't seem to matter for UV or normal
gl.BufferData(gl.ARRAY_BUFFER, len(indexedUVs)*2*4, indexedUVs, gl.STATIC_DRAW)
normBuffer := gl.GenBuffer()
defer normBuffer.Delete()
normBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(indexedNormals)*3*4, indexedNormals, gl.STATIC_DRAW)
elementBuffer := gl.GenBuffer()
defer elementBuffer.Delete()
elementBuffer.Bind(gl.ELEMENT_ARRAY_BUFFER)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(indices)*2, indices, gl.STATIC_DRAW) // NOTE: a GL_UNSIGNED_SHORT is 16-bits
lightID := prog.GetUniformLocation("LightPosition_worldspace")
lastTime := glfw.GetTime()
nbFrames := 0
// Equivalent to a do... while
for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
currTime := glfw.GetTime()
nbFrames++
if currTime-lastTime >= 1.0 {
fmt.Printf("%f ms/frame\n", 1000.0/float64(nbFrames))
nbFrames = 0
lastTime += 1.0
}
func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
prog.Use()
defer gl.ProgramUnuse()
view, proj := camera.ComputeViewPerspective()
model := mgl32.Ident4()
MVP := proj.Mul4(view).Mul4(model)
//mvpArray := mvp.AsCMOArray(mathgl.FLOAT32).([16]float32)
//vArray := view.AsCMOArray(mathgl.FLOAT32).([16]float32)
//mArray := model.AsCMOArray(mathgl.FLOAT32).([16]float32)
matrixID.UniformMatrix4fv(false, MVP)
viewMatrixID.UniformMatrix4fv(false, view)
modelMatrixID.UniformMatrix4fv(false, model)
lightID.Uniform3f(4., 4., 4.)
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)
normAttrib := gl.AttribLocation(2)
normAttrib.EnableArray()
defer normAttrib.DisableArray()
normBuffer.Bind(gl.ARRAY_BUFFER)
defer normBuffer.Unbind(gl.ARRAY_BUFFER)
normAttrib.AttribPointer(3, gl.FLOAT, false, 0, nil)
elementBuffer.Bind(gl.ELEMENT_ARRAY_BUFFER)
defer elementBuffer.Unbind(gl.ELEMENT_ARRAY_BUFFER)
gl.DrawElements(gl.TRIANGLES, len(indices), gl.UNSIGNED_SHORT, nil)
window.SwapBuffers()
glfw.PollEvents()
}() // Defers unbinds and disables to here, end of the loop
}
}
func main() {
var programState programState
var err error
glfw.SetErrorCallback(errorCallback)
if !glfw.Init() {
panic("GLFW initialization failed.")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.SrgbCapable, glfw.True)
glfw.WindowHint(glfw.Resizable, glfw.False)
programState.Gl.Window, err = glfw.CreateWindow(640, 480, "Daggor", nil, nil)
if err != nil {
panic(err)
}
defer programState.Gl.Window.Destroy()
programState.Gl.glfwKeyEventList = makeGlfwKeyEventList()
programState.Gl.Window.SetKeyCallback(programState.Gl.glfwKeyEventList.Callback)
programState.Gl.Window.MakeContextCurrent()
if ec := gl.Init(); ec != 0 {
panic(fmt.Sprintf("OpenGL initialization failed with code %v.", ec))
}
// For some reason, here, the OpenGL error flag for me contains "Invalid enum".
// This is weird since I have not done anything yet. I imagine that something
// goes wrong in gl.Init. Reading the error flag clears it, so I do it.
// Here's the reason:
// https://github.com/go-gl/glfw3/issues/50
// Maybe I should not even ask for a core profile anyway.
// What are the advantages are asking for a core profile?
if err := glw.CheckGlError(); err != nil {
err.Description = "OpenGL has this error right after init for some reason."
//fmt.Println(err)
}
{
// Assert OpenGL >= 3.3.
major := programState.Gl.Window.GetAttribute(glfw.ContextVersionMajor)
minor := programState.Gl.Window.GetAttribute(glfw.ContextVersionMinor)
fmt.Printf("OpenGL version %v.%v.\n", major, minor)
if (major < 3) || (major == 3 && minor < 3) {
panic("OpenGL version 3.3 required, your video card/driver does not seem to support it.")
}
}
programState.Gl.context = glw.NewGlContext()
programState.Gl.Shapes[floorID] = sculpt.FloorInstNorm(programState.Gl.context.Programs)
programState.Gl.Shapes[ceilingID] = sculpt.CeilingInstNorm(programState.Gl.context.Programs)
programState.Gl.Shapes[wallID] = sculpt.WallInstNorm(programState.Gl.context.Programs)
{
// I do not like the default reference frame of OpenGl.
// By default, we look in the direction -z, and y points up.
// I want z to point up, and I want to look in the direction +x
// by default. That way, I move on an xy plane where z is the
// altitude, instead of having the altitude stuffed between
// the two things I use the most. And my reason for pointing
// toward +x is that I use the convention for trigonometry:
// an angle of 0 points to the right (east) of the trigonometric
// circle. Bonus point: this matches Blender's reference frame.
myFrame := glm.ZUP.Mult(glm.RotZ(90))
eye_to_clip := glm.PerspectiveProj(110, 640./480., .1, 100).Mult(myFrame)
programState.Gl.context.SetEyeToClp(eye_to_clip)
}
gl.Enable(gl.FRAMEBUFFER_SRGB)
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.CULL_FACE)
gl.CullFace(gl.BACK)
gl.FrontFace(gl.CCW)
gl.Enable(gl.TEXTURE_CUBE_MAP_SEAMLESS)
// This needs a texture server attached to the context, like for programs.
glw.LoadSkybox()
programState.World = world.MakeWorld()
mainLoop(programState)
}
func (me *context) Window(winf *ngctx.WinProfile, bufSize *ngctx.BufferBits, ctxProf *ngctx.CtxProfile) (window ngctx.Window, err error) {
glfw.WindowHint(glfw.Samples, winf.MultiSampling)
glfw.WindowHint(glfw.RedBits, bufSize.Color.R)
glfw.WindowHint(glfw.GreenBits, bufSize.Color.G)
glfw.WindowHint(glfw.BlueBits, bufSize.Color.B)
glfw.WindowHint(glfw.AlphaBits, bufSize.Color.A)
glfw.WindowHint(glfw.DepthBits, bufSize.Depth)
glfw.WindowHint(glfw.StencilBits, bufSize.Stencil)
glfw.WindowHint(glfw.ContextVersionMajor, ctxProf.Version.Major)
glfw.WindowHint(glfw.ContextVersionMinor, ctxProf.Version.Minor)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
if ctxProf.ForwardCompat {
glfw.WindowHint(glfw.OpenglForwardCompatible, 1)
}
var mon *glfw.Monitor
if winf.FullScreen {
mon, err = glfw.GetPrimaryMonitor()
}
if err == nil {
var win *glfw.Window
if win, err = glfw.CreateWindow(winf.Width, winf.Height, winf.Title, mon, nil); win != nil {
window = newWindow(win)
if winf.FullScreen {
win.SetInputMode(glfw.Cursor, glfw.CursorHidden)
}
}
}
return
}
func (me *context) Hint(flag, value int) {
glfw.WindowHint(glfw.Hint(flag), value)
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 7", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
window.SetCursorPosition(1024/2, 768/2)
window.SetInputMode(glfw.Cursor, glfw.CursorHidden)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)
camera := input.NewCamera(window)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
texture, err := helper.TextureFromDDS("uvmap.DDS")
if err != nil {
fmt.Println("Couldn't load texture")
return
}
defer texture.Delete()
texSampler := prog.GetUniformLocation("myTextureSampler")
meshObj := objloader.LoadObject("cube.obj", true)
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 = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
prog.Use()
defer gl.ProgramUnuse()
view, proj := camera.ComputeViewPerspective()
model := mgl32.Ident4()
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))
window.SwapBuffers()
glfw.PollEvents()
}() // Defers unbinds and disables to here, end of the loop
}
}
func main() {
runtime.LockOSThread()
var looping = true
defer fmt.Println("EXIT")
// if err = glfw.Init(); err != nil {
// panic(err)
// }
if !glfw.Init() {
panic("glfw.Init() failed!")
}
defer glfw.Terminate()
// glfw.OpenWindowHint(glfw.FsaaSamples, 0)
glfw.WindowHint(glfw.Samples, 0)
if useStrictCoreProfile {
// glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
// glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 2)
// glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(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.WindowHint(glfw.RedBits, 8)
glfw.WindowHint(glfw.BlueBits, 8)
glfw.WindowHint(glfw.GreenBits, 8)
glfw.WindowHint(glfw.AlphaBits, 0)
glfw.WindowHint(glfw.DepthBits, 24)
glfw.WindowHint(glfw.StencilBits, 8)
win, err := glfw.CreateWindow(1280, 720, "Test", nil, nil)
if err != nil {
panic(err)
}
defer win.Destroy()
win.MakeContextCurrent()
// glfw.Enable(glfw.StickyKeys)
win.SetInputMode(glfw.StickyKeys, glfw.True)
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) {
if win.ShouldClose() || win.GetKey(glfw.KeyEscape) == glfw.Press {
looping = false
} else {
// glfw.SwapBuffers()
win.SwapBuffers()
glfw.PollEvents()
}
isFirstLoop = false
}
logLastGlError("post-loop")
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 4", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
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 := mgl32.Perspective(45.0, 4.0/3.0, 0.1, 100.0)
View := mgl32.LookAt(4.0, 3.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
Model := mgl32.Ident4()
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 = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
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()
window.SwapBuffers()
glfw.PollEvents()
}
}
// NewWindow creates a new window for the given dimensions and title.
// The window is created via GLFW.
func NewWindow(settings WindowSettings) (*Window, error) {
// Error callback
glfw.SetErrorCallback(errorCallback)
// Init glfw
logger.Debug("Initializing GLFW")
if !glfw.Init() {
return nil, errors.New("Could not initialise GLFW.")
}
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglDebugContext, 1)
var monitor *glfw.Monitor
var err error
if settings.Fullscreen {
logger.Debug("Get primary monitor to create fullscreen window.")
monitor, err = glfw.GetPrimaryMonitor()
if err != nil {
return nil, err
}
logger.Debug("Checking available video modes:")
videoModes, err := monitor.GetVideoModes()
if err != nil {
return nil, err
}
for _, videoMode := range videoModes {
logger.Debug(fmt.Sprintf("-- %+v", videoMode))
}
idealVideoMode := videoModes[len(videoModes)-1]
settings.Width = idealVideoMode.Width
settings.Height = idealVideoMode.Height
}
// Create window
logger.Info("Creating new window")
window, err := glfw.CreateWindow(settings.Width, settings.Height, settings.Title, monitor, nil)
if err != nil {
return nil, err
}
window.SetKeyCallback(keyCallback)
window.MakeContextCurrent()
window.SetInputMode(glfw.StickyKeys, 1)
// Use vsync
glfw.SwapInterval(1)
w := &Window{
window: window,
Settings: settings,
}
currentWindow = w
return w, nil
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 3", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
gl.ClearColor(0., 0., 0.4, 0.)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("SimpleTransform.vertexshader", "SingleColor.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
Projection := mgl32.Perspective(45.0, 4.0/3.0, 0.1, 100.0)
//Projection := mathgl.Identity(4,mathgl.FLOAT64)
//Projection := mathgl.Ortho2D(-5,5,-5,5)
View := mgl32.LookAt(4.0, 3.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
//View := mathgl.Identity(4,mathgl.FLOAT64)
Model := mgl32.Ident4()
//Model := mathgl.Scale3D(2.,2.,2.).Mul(mathgl.HomogRotate3DX(25.0)).Mul(mathgl.Translate3D(.5,.2,-.7))
MVP := Projection.Mul4(View).Mul4(Model) // Remember, transform multiplication order is "backwards"
vBufferData := [...]float32{
-1., -1., 0.,
1., -1., 0.,
0., 1., 0.}
//elBufferData := [...]uint8{0, 1, 2} // Not sure why this is here
buffer := gl.GenBuffer()
defer buffer.Delete()
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 = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
gl.Clear(gl.COLOR_BUFFER_BIT)
prog.Use()
matrixID.UniformMatrix4fv(false, MVP)
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()
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
runtime.LockOSThread()
verbose := flag.Bool("verbose", false, "produce verbose output")
debug := flag.Bool("debug", false, "produce debug output")
size := flag.String("size", "320x480", "set the size of the window")
flag.Parse()
if *verbose {
mandala.Verbose = true
}
if *debug {
mandala.Debug = true
}
dims := strings.Split(strings.ToLower(*size), "x")
width, err := strconv.Atoi(dims[0])
if err != nil {
panic(err)
}
height, err := strconv.Atoi(dims[1])
if err != nil {
panic(err)
}
if !glfw.Init() {
panic("Can't init glfw!")
}
defer glfw.Terminate()
// Enable OpenGL ES 2.0.
glfw.WindowHint(glfw.ClientApi, glfw.OpenglEsApi)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
window, err := glfw.CreateWindow(width, height, "{{.AppName}}", nil, nil)
if err != nil {
panic(err)
}
mandala.Init(window)
// Create a rendering loop control struct containing a set of
// channels that control rendering.
renderLoopControl := newRenderLoopControl()
// Start the rendering loop
loop.GoRecoverable(
renderLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
log.Printf("%s\n%s", r.Reason, mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
// Start the event loop
loop.GoRecoverable(
eventLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
log.Printf("%s\n%s", r.Reason, mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
for !window.ShouldClose() {
glfw.WaitEvents()
}
}
// Starts a game loop.
// If error == nil everything went well, otherwise a fatal error occured
func Gameloop(g Game, width, height, tickrate int, glfwHints map[glfw.Hint]int) (err error) {
// Disable GC
debug.SetGCPercent(-1)
// Make sure this function/goroutine keeps running on the current OS thread
runtime.LockOSThread()
// Calculate tick delay
nanosPerTick := int64(NANOS_PER_SECOND / tickrate)
// Variables for statistics
ticks := 0
frames := 0
// Initialize game
g.Init()
defer g.Cleanup()
// Setup window
glfw.SetErrorCallback(g.HandleGlfwError)
if !glfw.Init() {
err = errors.New("gogame: glfw failed to initialize")
return
}
defer glfw.Terminate()
for target, hint := range glfwHints {
glfw.WindowHint(target, hint)
}
window, err := glfw.CreateWindow(width, height, "GoGame", nil, nil)
if err != nil {
// Just to be verbose
err = err
return
}
// Set callbacks
window.SetFramebufferSizeCallback(g.HandleReshape)
window.SetKeyCallback(g.HandleKey)
window.MakeContextCurrent()
// TODO: Investigate double buffering/vsync
glfw.SwapInterval(1)
if gl.Init() != 0 { // GLEW_OK
err = errors.New("gogame: error initializing opengl/glew")
return
}
// Manually reshape window
width, height = window.GetFramebufferSize()
g.HandleReshape(window, width, height)
// Let the game initialize its graphics
g.InitGL()
defer g.CleanupGL()
last_out := time.Now().UnixNano()
previous := time.Now().UnixNano()
unprocessed := int64(0)
for !window.ShouldClose() {
current := time.Now().UnixNano()
elapsed := current - previous
previous = current
unprocessed += elapsed
for unprocessed >= nanosPerTick {
if g.OnUpdate() {
window.SetShouldClose(true)
}
ticks++
unprocessed -= nanosPerTick
}
if true {
substep := float32(unprocessed) / float32(nanosPerTick)
g.OnRender(substep)
frames++
}
if current-last_out >= NANOS_PER_SECOND {
// TODO: Pass tps and fps to game instead of logging here
log.Printf("%d TPS, %d FPS", ticks, frames)
ticks = 0
frames = 0
last_out += NANOS_PER_SECOND
}
// Manually call GC
runtime.GC()
// Swap buffers
window.SwapBuffers()
glfw.PollEvents()
// TODO: Look into handling sleeping between frames
/*elapsed_time := time.Duration(time.Now().UnixNano()) - previous
sleep_time := NANOS_PER_FRAME - elapsed_time // TODO: Decrease sleep time?
if sleep_time >= SLEEP_THRESHOLD {
time.Sleep(sleep_time)
}*/
}
err = nil
return
}
func main() {
f, err := os.Create("Go.pprof") // Create file for profiling
if err != nil {
panic(err)
}
glfw.SetErrorCallback(errorCallback)
if !glfw.Init() {
panic("Can't init glfw!")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 2)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
window, err := glfw.CreateWindow(Width, Height, Title, nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
glfw.SwapInterval(0) // No limit on FPS
gl.Init()
initScene()
loadCubeToGPU()
for !window.ShouldClose() {
frameInitT = time.Now()
movPts(frameDur)
doWind()
if spwnTmr >= SpawnInterval {
spwnPts(SpawnInterval)
spwnTmr -= SpawnInterval
}
if cleanupTmr >= float64(MaxLife)/1000 {
cleanupPtPool()
cleanupTmr = 0
}
checkColls()
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gpuInitT = time.Now()
renderPts()
window.SwapBuffers()
gpuEndT = time.Now()
glfw.PollEvents()
frameEndT = time.Now()
frameDur = frameEndT.Sub(frameInitT).Seconds() // Calculate the length of the previous frame
spwnTmr += frameDur
cleanupTmr += frameDur
runTmr += frameDur
if runTmr > MaxLife/1000 { // Start collecting framerate data and profiling after a full MaxLife worth of particles have been spawned
frames[curFrame] = frameDur
gpuTimes[curFrame] = gpuEndT.Sub(gpuInitT).Seconds()
curFrame += 1
pprof.StartCPUProfile(f)
}
if runTmr >= RunningTime { // Animation complete; calculate framerate mean and standard deviation
pprof.StopCPUProfile()
var sum float64
var i uint64
for i = 0; i < curFrame; i++ {
sum += frames[i]
}
frameTimeMean := sum / float64(curFrame)
fmt.Println("Average framerate was:", 1/frameTimeMean, "frames per second.")
sum = 0
for i = 0; i < curFrame; i++ {
sum += gpuTimes[i]
}
gpuTimeMean := sum / float64(curFrame)
fmt.Println("Average cpu time was-", frameTimeMean-gpuTimeMean, "seconds per frame.")
sumDiffs := 0.0
for i = 0; i < curFrame; i++ {
sumDiffs += math.Pow(1/frames[i]-1/frameTimeMean, 2)
}
variance := sumDiffs / float64(curFrame)
sd := math.Sqrt(variance)
fmt.Println("The standard deviation was:", sd, "frames per second.")
if PrintFrames == true {
fmt.Print("--:")
for i = 0; i < curFrame; i++ {
fmt.Print(1 / frames[i])
fmt.Print(",")
}
fmt.Print(".--")
}
break
}
}
gl.DisableClientState(gl.NORMAL_ARRAY)
gl.DisableClientState(gl.VERTEX_ARRAY)
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 2", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
gl.ClearColor(0., 0., 0.4, 0.)
vBufferData := [...]float32{
-1., -1., 0.,
1., -1., 0.,
0., 1., 0.}
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
prog := helper.MakeProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader")
buffer := gl.GenBuffer()
buffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData[0], gl.STATIC_DRAW)
// Equivalent to a do... while
for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
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()
window.SwapBuffers()
glfw.PollEvents()
}
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 6", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
window.SetCursorPosition(1024/2, 768/2)
window.SetInputMode(glfw.Cursor, glfw.CursorHidden)
gl.ClearColor(0., 0., 0.4, 0.)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)
camera := input.NewCamera(window)
vertexArray := gl.GenVertexArray()
defer vertexArray.Delete()
vertexArray.Bind()
prog := helper.MakeProgram("TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader")
defer prog.Delete()
matrixID := prog.GetUniformLocation("MVP")
texture, err := helper.TextureFromDDS("uvtemplate.DDS")
if err != nil {
fmt.Printf("Couldn't make texture: %v\n", err)
return
}
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,
}
// Invert V because we're using a compressed texture
for i := 1; i < len(uvBufferData); i += 2 {
uvBufferData[i] = 1.0 - uvBufferData[i]
}
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 = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
func() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
prog.Use()
defer gl.ProgramUnuse()
view, proj := camera.ComputeViewPerspective()
model := mgl32.Ident4()
MVP := proj.Mul4(view).Mul4(model)
//mvpArray := mvp.AsCMOArray(mathgl.FLOAT32).([16]float32)
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)
window.SwapBuffers()
glfw.PollEvents()
}() // Defers unbinds and disables to here, end of the loop
}
}
func main() {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
fmt.Println("OpenTibia Map Editor")
conf := &Configuration{}
conf.Load("config.json")
var sprLoader client.SpriteLoader
var datLoader client.DatLoader
var itemLoader ot.ItemLoader
//var otbLoader ot.OtbLoader
//var otMap ot.Map
var group sync.WaitGroup
group.Add(3)
go func() {
if err := sprLoader.Load(conf.SprFile); err != nil {
log.Fatal(err)
}
group.Done()
}()
go func() {
if err := datLoader.Load(conf.DatFile); err != nil {
log.Fatal(err)
}
group.Done()
}()
go func() {
if err := itemLoader.LoadXML("items.xml"); err != nil {
log.Fatal(err)
}
group.Done()
}()
/*
go func() {
if err := otbLoader.Load("items.otb"); err != nil {
log.Fatal(err)
}
otMap.Initialize()
if err := otMap.ReadOTBM("forgotten.otbm", &otbLoader); err != nil {
log.Fatal(err)
}
group.Done()
}()
*/
group.Wait()
if !glfw.Init() {
panic("Failed to initialize GLFW")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
window, err := glfw.CreateWindow(640, 480, "Map Editor", nil, nil)
if err != nil {
panic(err)
}
window.SetKeyCallback(keyHandler)
window.MakeContextCurrent()
if err := gl.Init(); err != 0 {
log.Fatal("Could not init gl")
}
log.Printf("OpenGL Version: %s", gl.GetString(gl.VERSION))
log.Printf("GLSL Version: %s", gl.GetString(gl.SHADING_LANGUAGE_VERSION))
log.Printf("Vendor: %s", gl.GetString(gl.VENDOR))
log.Printf("Renderer: %s", gl.GetString(gl.RENDERER))
r := renderer.Renderer{}
r.Initialize()
r.SetViewport(0, 0, 800, 600)
for !window.ShouldClose() {
r.Render()
window.SwapBuffers()
glfw.PollEvents()
}
/*
ids := datLoader.GetSpriteIDs(420)
sprite := sprLoader.GetSprite(ids[0])
img := image.NewNRGBA(image.Rect(0, 0, 32, 32))
img.Pix = sprite
out, _ := os.Create("test.png")
defer out.Close()
if err := png.Encode(out, img); err != nil {
log.Fatal(err)
}*/
}