// 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")
}