func main() { var err error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.CloseWindow() glfw.SetSwapInterval(1) glfw.SetWindowTitle(Title) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) gl.ShadeModel(gl.SMOOTH) gl.ClearColor(0, 0, 0, 0) gl.ClearDepth(1) gl.Enable(gl.TEXTURE_2D) for running && glfw.WindowParam(glfw.Opened) == 1 { update() draw() } }
func main() { var running bool = true 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() glfw.SetSwapInterval(1) glfw.SetWindowTitle(caption) if !horde3d.Init() { fmt.Println("Error starting Horde3D. Check Horde3d_log.html for details.") horde3d.DumpMessages() return } //horde3d.SetOption(horde3d.Options_DebugViewMode, 1) // Add resources //pipeline pipeRes = horde3d.AddResource(horde3d.ResTypes_Pipeline, "pipelines/hdr.pipeline.xml", 0) knightRes := horde3d.AddResource(horde3d.ResTypes_SceneGraph, "models/knight/knight.scene.xml", 0) //load resources paths separated by | horde3d.LoadResourcesFromDisk("../content") model := horde3d.RootNode.AddNodes(knightRes) model.SetTransform(0, 0, -30, 0, 0, 0, 0.1, 0.1, 0.1) // Add light source light := horde3d.RootNode.AddLightNode("Light1", 0, "LIGHTING", "SHADOWMAP") light.SetTransform(0, 20, 0, 0, 0, 0, 1, 1, 1) light.SetNodeParamF(horde3d.Light_RadiusF, 0, 50) //add camera cam = horde3d.RootNode.AddCameraNode("Camera", pipeRes) glfw.SetWindowSizeCallback(onResize) for running { horde3d.Render(cam) horde3d.FinalizeFrame() horde3d.DumpMessages() glfw.SwapBuffers() running = glfw.Key(glfw.KeyEsc) == 0 && glfw.WindowParam(glfw.Opened) == 1 } horde3d.Release() }
func (v *Video) Init(t <-chan []uint32, d <-chan []uint32, n string) { v.tick = t v.debug = d if err := glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } if err := glfw.OpenWindow(512, 480, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } if gl.Init() != 0 { panic("gl error") } gl.Enable(gl.TEXTURE_2D) glfw.SetWindowTitle(fmt.Sprintf("Fergulator - %s", n)) glfw.SetWindowSizeCallback(reshape) glfw.SetWindowCloseCallback(quit_event) glfw.SetKeyCallback(KeyListener) reshape(512, 480) v.tex = gl.GenTexture() v.fpsmanager = gfx.NewFramerate() v.fpsmanager.SetFramerate(70) }
func Open(w, h int, sWin string, fullscreen bool) *Window { if GWindow != nil { panic("only one Window is allowed") } listener.GListener = listener.New() win := &Window{width: w, height: h, title: sWin, inputListener: listener.GListener} GWindow = win var err error if err = glfw.Init(); err != nil { panic(fmt.Sprintf("[e] %v\n", err)) } mode := glfw.Windowed if fullscreen { mode = glfw.Fullscreen } if err = glfw.OpenWindow(win.width, win.height, 8, 8, 8, 0, 16, 0, mode); err != nil { panic(fmt.Sprintf("[e] %v\n", err)) } gl.Init() //WHY?? (shader creation fails when not) glfw.SetSwapInterval(1) // Enable vertical sync on cards that support it. glfw.SetWindowTitle(win.title) // Set window title //CALLBACKS glfw.SetWindowSizeCallback(func(w, h int) { GWindow.reshape(w, h) }) glfw.SetWindowCloseCallback(listener.OnClose) glfw.SetMouseButtonCallback(listener.OnMouseButton) glfw.SetMouseWheelCallback(listener.OnMouseWheel) glfw.SetKeyCallback(listener.OnKey) glfw.SetCharCallback(listener.OnChar) win.initGL() return win }
func main() { var err error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %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() { log.Println("Starting") flag.Parse() runtime.GOMAXPROCS(4) initGLFW() initGL() initScene() initInput() glfw.SetWindowSizeCallback(resize) initLua() // Run the script file if we had one // TODO: Do this before accepting input from user... if fScript != "" { runFile(fScript) } for glfw.WindowParam(glfw.Opened) == 1 { display() glfw.SwapBuffers() time.Sleep(10 * time.Millisecond) } }
func main() { rand.Seed(time.Now().UnixNano()) glfw.Init() defer glfw.Terminate() glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed) defer glfw.CloseWindow() glfw.SetSwapInterval(1) glfw.SetWindowTitle("Chipmunk demo") glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) initGL() initScene() Running = true for Running && glfw.WindowParam(glfw.Opened) == 1 { drawScene() space.Step(1.0 / 20.0 / 3.0) space.Step(1.0 / 20.0 / 3.0) space.Step(1.0 / 20.0 / 3.0) } }
func main() { log.Printf("Starting glfw window") err := glfw.Init() if err != nil { log.Fatalf("Error while starting glfw library: %v", err) } defer glfw.Terminate() err = glfw.OpenWindow(256, 256, 8, 8, 8, 0, 0, 0, glfw.Windowed) if err != nil { log.Fatalf("Error while opening glfw window: %v", err) } defer glfw.CloseWindow() glfw.SetSwapInterval(1) //vsync on glfw.SetWindowTitle("Colored Triangle") InitGL() glfw.SetWindowSizeCallback(func(w, h int) { InitGLWindow(w, h) }) glfw.SetKeyCallback(func(key, state int) { HandleKey(key, state) }) run := true for run && glfw.WindowParam(glfw.Opened) == 1 { select { case exitCode := <-exit: log.Printf("Received exit code: %d", exitCode) run = false default: Draw() } } }
func main() { var err error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %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() { globalState.Mouse = make(map[int]bool) flag.Parse() var err error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } if len(flag.Args()) == 0 { old := flag.Usage flag.Usage = func() { old() fmt.Fprintf(os.Stderr, "You MUST pass the name of the file to view\n") } flag.Usage() return } mesh, err = wfobj.LoadMeshFromFile(flag.Args()[0]) if err != nil { flag.Usage() fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.CloseWindow() glfw.SetSwapInterval(1) glfw.SetWindowTitle(Title) glfw.SetWindowSizeCallback(onResize) glfw.SetKeyCallback(onKey) glfw.SetCharCallback(onChar) glfw.SetMouseWheelCallback(onWheel) glfw.SetMouseButtonCallback(onMouseButton) glfw.SetMousePosCallback(onMousePos) initGL() running = true for running && glfw.WindowParam(glfw.Opened) == 1 { handleInput() drawScene() } }
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() { log.Printf("Starting glfw window") err := glfw.Init() if err != nil { log.Fatalf("Error while starting glfw library: %v", err) } defer glfw.Terminate() err = glfw.OpenWindow(256, 256, 8, 8, 8, 0, 0, 0, glfw.Windowed) if err != nil { log.Fatalf("Error while opening glfw window: %v", err) } defer glfw.CloseWindow() glfw.SetSwapInterval(1) //vsync on glfw.SetWindowTitle("Colored Triangle") InitGL() glfw.SetWindowSizeCallback(func(w, h int) { InitGLWindow(w, h) }) glfw.SetKeyCallback(func(key, state int) { HandleKey(key, state) }) // create a mesh with 3 vertices (a triangle) m := &Mesh{make([]*Vector, 3)} m.V[0] = &Vector{0, 1, 0, color.NRGBA{1, 0, 0, 0}} m.V[1] = &Vector{-1, -1, 0, color.NRGBA{0, 1, 0, 0}} m.V[2] = &Vector{1, -1, 0, color.NRGBA{0, 0, 1, 0}} run := true for run && glfw.WindowParam(glfw.Opened) == 1 { select { case exitCode := <-exit: log.Printf("Received exit code: %d", exitCode) run = false default: Draw(m) } } }
// Sets up input handlers func InitInputHandlers() { InitKeyHandlers() glfw.SetMousePosCallback(func(x, y int) { dx, dy := x-mousePrevX, y-mousePrevY mousePrevX, mousePrevY = x, y if mouseButton[0] == 0 { return } Rot[0] += int(deltaLook * float64(dx)) Rot[1] += int(deltaLook * float64(dy)) // limit viewing angles for i := range Rot { if Rot[i] > 360 { Rot[i] = 0 } if Rot[i] < 0 { Rot[i] += 360 } } log.Println("rot:", Rot) }) glfw.SetMouseButtonCallback(func(button, state int) { //log.Println("mousebutton:", button, state) mouseButton[button] = state }) glfw.SetMouseWheelCallback(func(delta int) { //log.Println("mousewheel:", delta) glfw.SetMouseWheel(0) }) glfw.SetWindowSizeCallback(func(w, h int) { Width, Height = w, h InitViewport() }) }
func main() { flag.Parse() var done bool var err os.Error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(300, 300, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } if gl.Init() != 0 { panic("gl error") } defer glfw.CloseWindow() glfw.SetWindowTitle("gears") glfw.SetWindowSizeCallback(reshape) init_() reshape(300, 300) done = false for !done { idle() draw() done = glfw.Key(glfw.KeyEsc) != 0 || glfw.WindowParam(glfw.Opened) == 0 } }
func main() { var err error if err = glfw.Init(); err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } path, err := gas.Abs("github.com/andrebq/wfobj/testdata/complex/complex.obj") if err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } mesh, err = wfobj.LoadMeshFromFile(path) if err != nil { fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer glfw.Terminate() if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { fmt.Fprintf(os.Stderr, "[e] %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 initWindow(caption string) { //glfw stuff err := glfw.Init() if err != nil { panic(err) } _w = 500 _h = 500 glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 2) glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3) glfw.OpenWindowHint(glfw.OpenGLProfile, 0) //glfw.OpenGLCoreProfile) err = glfw.OpenWindow(_w, _h, 0, 0, 0, 0, 0, 0, glfw.Windowed) if err != nil { panic(err) } glfw.SetWindowTitle(caption) glfw.Disable(glfw.AutoPollEvents) glfw.SetWindowSizeCallback(onResize) }
func NewWindow(r Renderer) (*Window, error) { w := &Window{r, time.Now()} var err error // Fail if the window is in use, even after its // finalizer has had a change to run. if busy { runtime.GC() runtime.GC() if busy { return nil, err } } if err = glfw.Init(); err != nil { goto abort_with_nothing } if err = glfw.OpenWindow(1024, 1024, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil { goto abort_with_glfw_init } if gl.Init() != 0 { goto abort_with_open_window } glfw.SetWindowTitle(os.Args[0]) glfw.SetWindowSizeCallback(reshape) glInit() reshape(1024, 1024) runtime.SetFinalizer(w, finalizeWindow) busy = true return w, nil abort_with_open_window: glfw.CloseWindow() abort_with_glfw_init: glfw.Terminate() abort_with_nothing: return nil, error(err) }
func main() { log.SetFlags(log.Lshortfile) //parse flags flag.Parse() if flags.cpuprofile != "" { f, err := os.Create(flags.cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } loadSettingsFile() Settings.Paused = flags.startPaused if flags.buildExamples { allExamples() return } wx, wy := 800, 600 //initialize opengl & glfw { //init glfw if err := glfw.Init(); err != nil { log.Printf("Error initializing glfw: %v\n", err) return } defer glfw.Terminate() //set window hints glfw.OpenWindowHint(glfw.WindowNoResize, 1) //create the window if err := glfw.OpenWindow(wx, wy, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { log.Printf("Error opening Window: %v\n", err) return } defer glfw.CloseWindow() //init opengl if gl.Init() != 0 { panic("gl error") } //glfw config { glfw.SetSwapInterval(1) glfw.SetWindowTitle("mater test") } //set additional opengl stuff { gl.ClearColor(0, 0, 0, 0) gl.Enable(gl.BLEND) //gl.BlendFunc (gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); gl.Enable(gl.TEXTURE_2D) } } //setup scene related stuff { //create empty space space = collision.NewSpace() } //reload settings so they take effect reloadSettings() saveSettingsFile() //set callbacks { glfw.SetWindowSizeCallback(OnResize) glfw.SetKeyCallback(OnKey) } //init debug console console.Init() //load savefile passed from the commandline if any if flags.file != "" { err := loadSpace(flags.file) Settings.Paused = true if err != nil { panic(err) } } //if set to true once a second printFPS := false //fix timestep to given fps const expectedFps = 30.0 const expectedFrameTime = 1.0 / expectedFps //the time at the start of the last frame lastTime := 0.0 acc := 0.0 updateAcc := 0.0 frameCount := 0 updateFrameCount := 0 fps := 0 updateFps := 0 Settings.Running = true for Settings.Running && glfw.WindowParam(glfw.Opened) == 1 { time := glfw.Time() //get the time elapsed since the last frame dt := time - lastTime lastTime = time //advance framecount and accumulators frameCount++ acc += dt updateAcc += dt //execute console commands if any select { case command := <-console.Command: console.ExecuteCommand(command) default: } //update the scene at a fixed timestep for updateAcc >= expectedFrameTime { updateFrameCount++ //if one second has passed update the fps and reset the framecount if acc > 1 { updateFps = updateFrameCount updateFrameCount = 0 } //only update if not paused or if set to advance a single frame if !Settings.Paused || Settings.SingleStep { space.Step(expectedFrameTime) Settings.SingleStep = false } updateAcc -= expectedFrameTime } //draw debug data Draw() glfw.SwapBuffers() //if one second has passed update the fps and reset the framecount if acc > 1 { fps = frameCount frameCount = 0 if printFPS { fmt.Printf("---\n") fmt.Printf("FPS: %v\n", fps) fmt.Printf("Update FPS: %v\n", updateFps) fmt.Printf("Average frametime: %v\n", acc/float64(fps)) fmt.Printf("---\n") } acc -= 1 } } }
func setCallbacks() { glfw.SetWindowSizeCallback(handleResize) glfw.SetWindowCloseCallback(Cleanup) }
func (w *window) SetSizeCallback(f func(int, int)) { glfw.SetWindowSizeCallback(func(width, height int) { f(width, height) }) }
func main() { w := 500 h := 500 fov := 45.0 clip_min := 0.1 clip_max := 1000.0 aspect_ratio := float64(w) / float64(h) glfw.Init() glfw.OpenWindow(w, h, 8, 8, 8, 8, 8, 0, glfw.Windowed) glfw.SetWindowTitle("Shader Test") glfw.SetWindowSizeCallback(resize_window) glfw.SetKeyCallback(key_callback) gl.ClearColor(0.3, 0.3, 0.3, 1.0) gl.ShadeModel(gl.SMOOTH) size_window(w, h, fov, aspect_ratio, clip_min, clip_max) //Testing sprites test_sprite := sprite{height: 1.0, width: 1.0} test_sprite.tex = texture("./assets/hedge.gif") test_sprite.Y = 3 new_guy := sprite{height: 0.5, width: 0.5} new_guy.tex = texture("./assets/red2.png") new_guy.Y = 5 renderees := new(list.List) renderees.PushBack(&new_guy) renderees.PushBack(&test_sprite) my_camera.init(Vector{0.0, -1.0, 0.0}) my_camera.front = Vector{0.0, 1.0, 0.0} my_camera.top = Vector{0.0, 0.0, 1.0} //End testing sprites physics_objects := new(list.List) physics_objects.PushBack(my_camera) dt, err := time.ParseDuration("16.67ms") if err != nil { die(err) } fmt.Println("Timestep: ", dt) var t float64 = 0 running := true for running { t0 := time.Now() update(physics_objects, float64(dt.Nanoseconds())/1e6) t += 0.025 new_guy.X = math.Cos(t) new_guy.Y = math.Sin(t) + 3.0 //my_camera.point_at(Vector{new_guy.X, new_guy.Y, new_guy.Z}) general_render(renderees, my_camera) glfw.SwapBuffers() dt = time.Since(t0) rate := time.Microsecond * 16670 if dt < rate { time.Sleep((rate - dt)) //fmt.Println("This frame took", float64(dt.Nanoseconds())/1000000, "ms to render.") } running = glfw.Key(glfw.KeyEsc) == 0 && glfw.WindowParam(glfw.Opened) != 0 } }
func main() { // We need to lock the goroutine to one thread due time.Ticker runtime.LockOSThread() var err os.Error err = glfw.Init() if err != nil { fmt.Printf("GLFW: %s\n", err) return } defer glfw.Terminate() // You could probably change the required versions down glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3) glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3) glfw.OpenWindowHint(glfw.OpenGLProfile, 1) // Open Window with 8 bit Alpha err = glfw.OpenWindow(ScreenWidth, ScreenHeight, 0, 0, 0, 8, 8, 0, glfw.Windowed) if err != nil { fmt.Printf("GLFW: %s\n", err) return } defer glfw.CloseWindow() glfw.SetWindowTitle(WindowTitle) glfw.SetWindowSizeCallback(onResize) major, minor, rev := glfw.GLVersion() if major < 3 { fmt.Printf("Error your graphic card does not support OpenGL 3.3\n Your GL-Version is: %d, %d, %d\n", major, minor, rev) fmt.Println("You can try to lower the settings in glfw.OpenWindowHint(glfw.OpenGLVersionMajor/Minor.") } initStatus := gl.Init() // Init glew if initStatus != 0 { fmt.Printf("Error-code: %d Init-Status: %d\n", gl.GetError(), initStatus) } // Enable transparency in OpenGL gl.Enable(gl.BLEND) gl.Enable(gl.DEPTH_TEST) //gl.DepthFunc(gl.LESS) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) initResources() // We are limiting the calls to display() (frames per second) to 60. This prevents the 100% cpu usage. ticker := time.NewTicker(int64(second) / 60) // max 60 fps for { <-ticker.C angle := float32(glfw.Time()) anim := math3d.MakeYRotationMatrix(angle) model := math3d.MakeTranslationMatrix(0, 0, -4) view := math3d.MakeLookAtMatrix(math3d.Vector3{0, 2, 0}, math3d.Vector3{0, 0, -4}, math3d.Vector3{0, 1, 0}) projection := math3d.MakePerspectiveMatrix(45, float32(ScreenWidth)/float32(ScreenHeight), 0.1, 10.0) matrix = math3d.MakeIdentity().Multiply(projection).Multiply(view).Multiply(model).Multiply(anim) program.Use() uniformMTransform.UniformMatrix4fv(1, false, matrix.Transposed()) display() } // Free resources free() runtime.UnlockOSThread() }