// initGL initializes GLFW and OpenGL. func initGL(c *cpu.CPU, width, height int) error { err := glfw.Init() if err != nil { return err } glfw.OpenWindowHint(glfw.WindowNoResize, 1) err = glfw.OpenWindow(width, height, 8, 8, 8, 8, 8, 0, glfw.Windowed) if err != nil { glfw.Terminate() return err } glfw.SetWindowTitle("DCPU") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) gl.Init() err = glh.CheckGLError() if err != nil { return err } gl.Disable(gl.LIGHTING) gl.Disable(gl.DEPTH_TEST) gl.Enable(gl.TEXTURE_2D) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.ClearColor(0, 0, 0, 1) return err }
// initGL initializes GLFW and OpenGL. func initGL() error { err := glfw.Init() if err != nil { return err } err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed) if err != nil { glfw.Terminate() return err } glfw.SetWindowTitle("go-gl/gltext: Bitmap font example") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) errno := gl.Init() if errno != gl.NO_ERROR { str, err := glu.ErrorString(errno) if err != nil { return fmt.Errorf("Unknown openGL error: %d", errno) } return fmt.Errorf(str) } gl.Disable(gl.DEPTH_TEST) gl.Disable(gl.LIGHTING) gl.ClearColor(0.2, 0.2, 0.23, 0.0) return nil }
// Opens a new window. func (c *Controller) Open(win *Window) (err error) { c.Win = win mode := glfw.Windowed if win.Fullscreen { mode = glfw.Fullscreen } if win.Resize == false { glfw.OpenWindowHint(glfw.WindowNoResize, 1) } if err = glfw.OpenWindow(win.Width, win.Height, 0, 0, 0, 0, 0, 0, mode); err != nil { return } gl.Init() gl.Enable(gl.TEXTURE_2D) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) v1, v2, v3 := glfw.GLVersion() log.Printf("OpenGL version: %v %v %v\n", v1, v2, v3) fb_supported := glfw.ExtensionSupported("GL_EXT_framebuffer_object") log.Printf("Framebuffer supported: %v\n", fb_supported) c.SetClearColor(0, 0, 0, 0) if win.VSync == true { glfw.SetSwapInterval(1) // Limit to refresh } glfw.SetWindowTitle(win.Title) glfw.SetWindowSizeCallback(func(w, h int) { log.Printf("Resizing window to %v, %v\n", w, h) c.resize() }) err = c.resize() return }
// Initialize the window. Returns an error if glfw or glew throws one. func InitWindow(width, height int) error { Width, Height = width, height err := glfw.Init() if err != nil { return err } err = glfw.OpenWindow(Width, Height, 0, 0, 0, 32, 32, 32, glfw.Windowed) if err != nil { return err } WindowOpened = true glfw.SetWindowTitle("Goliath") glfw.Enable(glfw.KeyRepeat) if ret := gl.Init(); ret != 0 { return fmt.Errorf("failed to initialize GLEW: %d", ret) } // Set GL states gl.ClearColor(0.0, 0.0, 0.0, 1.0) gl.Enable(gl.CULL_FACE) gl.CullFace(gl.BACK) gl.FrontFace(gl.CCW) err = InitShaders() if err != nil { return err } InitCamera(Width, Height) return nil }
func (v *Video) Init(w int, h int) { var err error if err = glfw.Init(); err != nil { log.Fatal(err) } glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE) if err = glfw.OpenWindow(w, h, 8, 8, 8, 0, 24, 0, glfw.Windowed); err != nil { log.Fatal(err) } if gl.Init() != 0 { log.Fatal("ummm... hmmm") } glfw.SetWindowSizeCallback(resize) gl.Enable(gl.TEXTURE_2D) resize(w, h) v.Texture = gl.GenTexture() }
func Init() { runtime.LockOSThread() // Initialize GLFW var err error if err = glfw.Init(); err != nil { log.Fatalf("%v\n", err) return } err = glfw.OpenWindow(SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0, 0, 0, 0, glfw.Windowed) if err != nil { log.Fatalf("%v\n", err) return } glfw.SetWindowTitle("Mandelbrot") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) glfw.SetWindowCloseCallback(onClose) glfw.SetMouseButtonCallback(onMouseBtn) glfw.SetMouseWheelCallback(onMouseWheel) glfw.SetKeyCallback(onKey) glfw.SetCharCallback(onChar) // Initialize OpenGL gl.Disable(gl.DEPTH_TEST) gl.ClearColor(0, 0, 0, 0) }
func init() { go func() { runtime.LockOSThread() if err := glfw.Init(); err != nil { log.Panic("glfw Error:", err) } w, h := 100, 100 err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed) if err != nil { log.Panic("Error:", err) } if gl.Init() != 0 { log.Panic("gl error") } glfw.SetWindowSizeCallback(Reshape) glfw.SwapBuffers() for { (<-main_thread_setup)() glfw.SwapBuffers() (<-main_thread_after)() main_thread_work_done <- true } }() }
func main() { var err error if err = glfw.Init(); err != nil { log.Fatalf("%v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { log.Fatalf("%v\n", err) return } defer glfw.CloseWindow() glfw.SetSwapInterval(1) glfw.SetWindowTitle(Title) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) if err = initGL(); err != nil { log.Fatalf("%v\n", err) return } defer destroyGL() running = true for running && glfw.WindowParam(glfw.Opened) == 1 { drawScene() } }
func main() { var err error if err = glfw.Init(); err != nil { log.Fatalf("%v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed); err != nil { log.Fatalf("%v\n", err) return } defer glfw.CloseWindow() glfw.SetWindowTitle("Draw") glfw.SetSwapInterval(1) glfw.SetKeyCallback(onKey) glfw.SetMouseButtonCallback(onMouseBtn) glfw.SetWindowSizeCallback(onResize) running = true for running && glfw.WindowParam(glfw.Opened) == 1 { if mouse[0] != 0 { pen.lineTo(glfw.MousePos()) } else { pen.moveTo(glfw.MousePos()) } glfw.SwapBuffers() } }
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 make_window(w, h int, title string) func() { // Required to make sure that the OpenGL go-routine doesn't get switched // to another thread (=> kerblammo) runtime.LockOSThread() if err := glfw.Init(); err != nil { log.Panic("glfw Error:", err) } err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed) if err != nil { log.Panic("Error:", err) } if gl.Init() != 0 { log.Panic("gl error") } if *vsync { glfw.SetSwapInterval(1) } else { glfw.SetSwapInterval(0) } glfw.SetWindowTitle(title) glfw.SetWindowSizeCallback(Reshape) Init() return func() { glfw.Terminate() glfw.CloseWindow() log.Print("Cleanup") } }
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() } }
// initGL initializes GLFW and OpenGL. func initGL() error { err := glfw.Init() if err != nil { return err } err = glfw.OpenWindow(AtlasSize, AtlasSize, 8, 8, 8, 8, 0, 0, glfw.Windowed) if err != nil { glfw.Terminate() return err } glfw.SetWindowTitle("Texture atlas example") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) gl.Init() if err = glh.CheckGLError(); err != nil { return err } gl.Disable(gl.DEPTH_TEST) gl.Disable(gl.LIGHTING) gl.Enable(gl.TEXTURE_2D) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.ClearColor(0.2, 0.2, 0.23, 1.0) return nil }
func 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) } } }
// initGL initializes GLFW and OpenGL. func initGL() error { err := glfw.Init() if err != nil { return err } glfw.OpenWindowHint(glfw.FsaaSamples, 4) err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 0, 0, glfw.Windowed) if err != nil { glfw.Terminate() return err } glfw.SetWindowTitle("Meshbuffer 2D example") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) gl.Init() if err = glh.CheckGLError(); err != nil { return err } gl.Disable(gl.DEPTH_TEST) gl.Enable(gl.MULTISAMPLE) gl.Disable(gl.LIGHTING) gl.Enable(gl.COLOR_MATERIAL) gl.ClearColor(0.2, 0.2, 0.23, 1.0) return nil }
func 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 StartEngine() { runtime.GOMAXPROCS(runtime.NumCPU()) runtime.LockOSThread() fmt.Println("Enginge started!") var err error if err = glfw.Init(); err != nil { panic(err) } fmt.Println("GLFW Initialized!") glfw.OpenWindowHint(glfw.Accelerated, 1) if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 8, 8, glfw.Windowed); err != nil { panic(err) } glfw.SetSwapInterval(1) //0 to disable vsync, 1 to enable it glfw.SetWindowTitle(windowTitle) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(input.OnKey) glfw.SetCharCallback(input.OnChar) glfw.SetMouseButtonCallback(input.ButtonPress) glfw.SetMouseWheel(0) glfw.SetMouseWheelCallback(input.MouseWheelCallback) input.MouseWheelPosition = glfw.MouseWheel input.MousePosition = glfw.MousePos if err = initGL(); err != nil { panic(err) } fmt.Println("Opengl Initialized!") TextureMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader) err = TextureMaterial.Load() if err != nil { fmt.Println(err) } SDFMaterial = NewBasicMaterial(sdfVertexShader, sdfFragmentShader) err = SDFMaterial.Load() if err != nil { fmt.Println(err) } internalMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader) err = internalMaterial.Load() if err != nil { fmt.Println(err) } initDefaultPlane() glfw.SwapBuffers() gameTime = time.Time{} lastTime = time.Now() dl = glfw.Time() }
func main() { if err := glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "%s\n", err.Error()) return } defer glfw.Terminate() glfw.OpenWindowHint(glfw.FsaaSamples, 4) glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3) glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3) glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "%s\n", err.Error()) return } gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked gl.GetError() // Ignore error glfw.SetWindowTitle("Tutorial 02") glfw.Enable(glfw.StickyKeys) gl.ClearColor(0., 0., 0.4, 0.) prog := helper.MakeProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader") vBufferData := [...]float32{ -1., -1., 0., 1., -1., 0., 0., 1., 0.} vertexArray := gl.GenVertexArray() vertexArray.Bind() buffer := gl.GenBuffer() buffer.Bind(gl.ARRAY_BUFFER) gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW) // Equivalent to a do... while for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) { gl.Clear(gl.COLOR_BUFFER_BIT) prog.Use() attribLoc := gl.AttribLocation(0) attribLoc.EnableArray() buffer.Bind(gl.ARRAY_BUFFER) attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil) gl.DrawArrays(gl.TRIANGLES, 0, 3) attribLoc.DisableArray() glfw.SwapBuffers() } }
func main() { var err error if err = glfw.Init(); err != nil { log.Fatalf("%v\n", err) return } defer glfw.Terminate() // Open window with FSAA samples (if possible). glfw.OpenWindowHint(glfw.FsaaSamples, 4) if err = glfw.OpenWindow(400, 400, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil { log.Fatalf("%v\n", err) return } defer glfw.CloseWindow() glfw.SetWindowTitle("Aliasing Detector") glfw.SetSwapInterval(1) if samples := glfw.WindowParam(glfw.FsaaSamples); samples != 0 { fmt.Printf("Context reports FSAA is supported with %d samples\n", samples) } else { fmt.Printf("Context reports FSAA is unsupported\n") } gl.MatrixMode(gl.PROJECTION) glu.Perspective(0, 1, 0, 1) for glfw.WindowParam(glfw.Opened) == 1 { time := float32(glfw.Time()) gl.Clear(gl.COLOR_BUFFER_BIT) gl.LoadIdentity() gl.Translatef(0.5, 0, 0) gl.Rotatef(time, 0, 0, 1) gl.Enable(GL_MULTISAMPLE_ARB) gl.Color3f(1, 1, 1) gl.Rectf(-0.25, -0.25, 0.25, 0.25) gl.LoadIdentity() gl.Translatef(-0.5, 0, 0) gl.Rotatef(time, 0, 0, 1) gl.Disable(GL_MULTISAMPLE_ARB) gl.Color3f(1, 1, 1) gl.Rectf(-0.25, -0.25, 0.25, 0.25) glfw.SwapBuffers() } }
func (rw *RenderWindow) Open() error { err := glfw.OpenWindow(int(rw.Width), int(rw.Height), 8, 8, 8, 8, 0, 0, glfw.Windowed) if err != nil { return err } glfw.SetWindowTitle(rw.Title) glfw.SetSwapInterval(2) glfw.SetKeyCallback(rw.onKey) glfw.SetWindowSizeCallback(rw.onResize) return nil }
func main() { fmt.Print("GLFW Init Start.") glfw.Init() fmt.Println(" GLFW Init Done.") defer glfw.Terminate() defer fmt.Println("example Terminating.") fmt.Println("GLFW Set Hints.") glfw.OpenWindowHint(glfw.WindowNoResize, 1) fmt.Print("GLFW Open Window Start.") glfw.OpenWindow(640, 480, 8, 8, 8, 0, 0, 0, glfw.Windowed) glfw.SetWindowTitle("example") fmt.Println(" GLFW Open Window Done.") v1, v2, v3 := glfw.GLVersion() fmt.Printf("OpenGL version: %d.%d.%d\n", v1, v2, v3) fmt.Printf("GLFW version: %d.%d.%d\n", glfw.VersionMajor, glfw.VersionMinor, glfw.VersionRevision) glfw.SetSwapInterval(1) fps := time.Duration(30) fmt.Printf("Creating %d Hz Ticker.", fps) ticker := time.NewTicker(time.Second / fps) fmt.Printf(" %d Hz Ticker Created\n", fps) closedWindow := glfwHelper.WindowCloseChan() mouseButtons := glfwHelper.MouseButtonChan() mousePos := glfwHelper.MousePosChan() mouseWheel := glfwHelper.MouseWheelChan() keyButtons := glfwHelper.KeyChan() charButtons := glfwHelper.CharChan() for { select { case <-ticker.C: glfw.SwapBuffers() case <-closedWindow: return case input := <-mouseButtons: fmt.Println(input) case input := <-mousePos: fmt.Println(input) case input := <-mouseWheel: fmt.Println(input) case input := <-keyButtons: fmt.Println(input) case input := <-charButtons: fmt.Println(string(input)) } } }
func 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 (s *System) CreateWindow(width, height int, title string) { if err := glfw.OpenWindow(width, height, 0, 0, 0, 8, 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 CheckGLErrors() // Ignore error glfw.SetWindowTitle(title) glfw.Enable(glfw.StickyKeys) gl.ClearColor(0., 0., 0., 0.) gl.Clear(gl.COLOR_BUFFER_BIT) }
func (_ *NgUserIO) recreateWin() (err error) { winInit := &Options.Initialization.Window if UserIO.Window.isCreated { glfw.CloseWindow() } if UserIO.Window.isCreated, err = false, glfw.OpenWindow(UserIO.Window.width, UserIO.Window.height, winInit.Rbits, winInit.Gbits, winInit.Bbits, winInit.Abits, winInit.DepthBits, winInit.StencilBits, ugo.Ifi(UserIO.Window.fullscreen, glfw.Fullscreen, glfw.Windowed)); err == nil { UserIO.Window.width, UserIO.Window.height = glfw.WindowSize() UserIO.Window.isCreated = true UserIO.Window.SetTitle(UserIO.Window.title) UserIO.Window.SetSwapInterval(UserIO.Window.swap) glfw.SetWindowCloseCallback(glfwOnWindowClose) glfw.SetWindowSizeCallback(glfwOnWindowResize) // glfw.Disable(glfw.MouseCursor) glfw.Disable(glfw.AutoPollEvents) glfw.Disable(glfw.StickyKeys) } return }
func (me *context) Window(winf *ngctx.WinProfile, bufSize *ngctx.BufferBits, ctxProf *ngctx.CtxProfile) (win ngctx.Window, err error) { glfw.OpenWindowHint(glfw.FsaaSamples, 0) // AA will be a pluggable post-processing shader glfw.OpenWindowHint(glfw.OpenGLVersionMajor, ctxProf.Version.Major) glfw.OpenWindowHint(glfw.OpenGLVersionMinor, ctxProf.Version.Minor) glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) if ctxProf.ForwardCompat { glfw.OpenWindowHint(glfw.OpenGLForwardCompat, 1) } winMode := glfw.Windowed if winf.FullScreen { winMode = glfw.Fullscreen } if err = glfw.OpenWindow(winf.Width, winf.Height, bufSize.Color.R, bufSize.Color.G, bufSize.Color.B, bufSize.Color.A, bufSize.Depth, bufSize.Stencil, winMode); err == nil { win = newWindow() win.SetTitle(winf.Title) if winMode == glfw.Fullscreen { glfw.Disable(glfw.MouseCursor) } } return }
// initGL initializes GLFW and OpenGL. func initGL() error { err := glfw.Init() if err != nil { return err } glfw.OpenWindowHint(glfw.FsaaSamples, 4) glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE) err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 32, 0, glfw.Windowed) if err != nil { glfw.Terminate() return err } glfw.SetWindowTitle("Meshbuffer 3D example") glfw.SetSwapInterval(1) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) gl.Init() if err = glh.CheckGLError(); err != nil { return err } gl.Enable(gl.DEPTH_TEST) gl.Enable(gl.MULTISAMPLE) gl.Disable(gl.LIGHTING) //gl.ClearColor(0.2, 0.2, 0.23, 1.0) gl.ClearColor(0, 0, 0, 1.0) gl.ShadeModel(gl.SMOOTH) gl.LineWidth(2) gl.ClearDepth(1) gl.DepthFunc(gl.LEQUAL) gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST) gl.ColorMaterial(gl.FRONT_AND_BACK, gl.AMBIENT_AND_DIFFUSE) return nil }
func (s *Display) init(title string, screenSizeMultiplier int) error { s.Name = PREFIX + "-SCREEN" log.Printf("%s: Initialising display", s.Name) var err error s.ScreenSizeMultiplier = screenSizeMultiplier log.Printf("%s: Set screen size multiplier to %dx", s.Name, s.ScreenSizeMultiplier) glfw.OpenWindowHint(glfw.WindowNoResize, 1) err = glfw.OpenWindow(SCREEN_WIDTH*s.ScreenSizeMultiplier, SCREEN_HEIGHT*s.ScreenSizeMultiplier, 0, 0, 0, 0, 0, 0, glfw.Windowed) if err != nil { return err } glfw.SetWindowTitle(title) //resize function onResize := func(w, h int) { gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(0, float64(w), float64(h), 0, -1, 1) gl.ClearColor(0.255, 0.255, 0.255, 0) gl.Clear(gl.COLOR_BUFFER_BIT) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() } glfw.SetWindowSizeCallback(onResize) desktopMode := glfw.DesktopMode() glfw.SetWindowPos((desktopMode.W-SCREEN_WIDTH*s.ScreenSizeMultiplier)/2, (desktopMode.H-SCREEN_HEIGHT*s.ScreenSizeMultiplier)/2) gl.ClearColor(0.255, 0.255, 0.255, 0) return nil }
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() { 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") }