func main() {
var (
err error
window *sdl.Window
context sdl.GLContext
)
if err = sdl.Init(sdl.INIT_EVERYTHING); err != nil {
panic(err)
}
defer sdl.Quit()
sdl.GL_SetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_COMPATIBILITY)
window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_OPENGL)
if err != nil {
panic(err)
}
defer window.Destroy()
context, err = sdl.GL_CreateContext(window)
if err != nil {
panic(err)
}
defer sdl.GL_DeleteContext(context)
if err = sdl.GL_MakeCurrent(window, context); err != nil {
panic(err)
}
if err = gl.Init(); err != nil {
panic(err)
}
sdl.GL_SetSwapInterval(1)
printGLInfo()
setupGL()
windowLoop(window)
}
// NewWindow will create a new sdl window with a gl context. It will also destroy
// an old one if there is one already. Errors returned come straight from SDL so
// errors will be indicitive of SDL errors
func NewWindow() (*window, error) {
if current_window != nil || initError != nil {
return current_window, initError
}
var config *windowConfig
var err error
if err = sdl.InitSubSystem(sdl.INIT_VIDEO); err != nil {
panic(err)
}
if config, err = loadConfig(); err != nil {
panic(err)
}
config.Minwidth = int32(math.Max(float64(config.Minwidth), 1.0))
config.Minheight = int32(math.Max(float64(config.Minheight), 1.0))
config.Display = int(math.Min(math.Max(float64(config.Display), 0.0), float64(GetDisplayCount()-1)))
if config.Width == 0 || config.Height == 0 {
var mode sdl.DisplayMode
sdl.GetDesktopDisplayMode(config.Display, &mode)
config.Width = mode.W
config.Height = mode.H
}
sdlflags := uint32(sdl.WINDOW_OPENGL)
if config.Fullscreen {
if config.Fstype == "desktop" {
sdlflags |= sdl.WINDOW_FULLSCREEN_DESKTOP
} else {
sdlflags |= sdl.WINDOW_FULLSCREEN
mode := sdl.DisplayMode{W: int32(config.Width), H: int32(config.Height)}
// Fullscreen window creation will bug out if no mode can be used.
if _, err := sdl.GetClosestDisplayMode(config.Display, &mode, &mode); err != nil {
// GetClosestDisplayMode will fail if we request a size larger
// than the largest available display mode, so we'll try to use
// the largest (first) mode in that case.
if err := sdl.GetDisplayMode(config.Display, 0, &mode); err != nil {
return nil, err
}
}
config.Width = mode.W
config.Height = mode.H
}
}
if config.Resizable {
sdlflags |= sdl.WINDOW_RESIZABLE
}
if config.Borderless {
sdlflags |= sdl.WINDOW_BORDERLESS
}
if config.Highdpi {
sdlflags |= sdl.WINDOW_ALLOW_HIGHDPI
}
if config.Fullscreen {
// The position needs to be in the global coordinate space.
var displaybounds sdl.Rect
sdl.GetDisplayBounds(config.Display, &displaybounds)
config.X += displaybounds.X
config.Y += displaybounds.Y
} else {
if config.Centered {
config.X = sdl.WINDOWPOS_CENTERED
config.Y = sdl.WINDOWPOS_CENTERED
} else {
config.X = sdl.WINDOWPOS_UNDEFINED
config.Y = sdl.WINDOWPOS_UNDEFINED
}
}
if current_window != nil {
Destroy()
}
created = false
new_window, err := createWindowAndContext(config, sdlflags)
if err != nil {
return nil, err
}
created = true
if new_window.Config.Icon != "" {
SetIcon(config.Icon)
}
SetMouseGrab(false)
SetMinimumSize(config.Minwidth, config.Minheight)
SetTitle(config.Title)
if config.Centered && !config.Fullscreen {
SetPosition(config.X, config.Y)
}
getCurrent().sdl_window.Raise()
if config.Vsync {
sdl.GL_SetSwapInterval(1)
} else {
sdl.GL_SetSwapInterval(0)
}
new_window.open = true
return new_window, nil
}
func main() {
runtime.LockOSThread()
flag.Parse()
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if err := sdl.Init(sdl.INIT_EVERYTHING); err != nil {
panic(err)
}
defer sdl.Quit()
sdl.GL_SetAttribute(sdl.GL_MULTISAMPLESAMPLES, 4)
sdl.GL_SetAttribute(sdl.GL_CONTEXT_MAJOR_VERSION, 3)
sdl.GL_SetAttribute(sdl.GL_CONTEXT_MINOR_VERSION, 3)
sdl.GL_SetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_CORE)
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
sdl.GL_SetAttribute(sdl.GL_DEPTH_SIZE, 24)
sdl.GL_SetAttribute(sdl.GL_CONTEXT_FLAGS, sdl.GL_CONTEXT_DEBUG_FLAG|sdl.GL_CONTEXT_FORWARD_COMPATIBLE_FLAG)
window, err := sdl.CreateWindow("TOW", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 1024, 768, sdl.WINDOW_OPENGL|sdl.WINDOW_SHOWN|sdl.WINDOW_RESIZABLE)
if err != nil {
log.Fatal("can't create window", err)
}
defer window.Destroy()
//defer renderer.Destroy()
glcontext, err := sdl.GL_CreateContext(window)
if err != nil {
log.Fatal("can't create context", err)
}
defer sdl.GL_DeleteContext(glcontext)
sdl.GL_MakeCurrent(window, glcontext)
//err := gl.GlewInit()
//fmt.Println(gl.GlewGetErrorString(err))
//glew init
gl.Init()
sdl.GL_SetSwapInterval(1)
fmt.Println("glVersion", gl.GetString(gl.VERSION))
tw.Init(tw.OPENGL_CORE, nil)
defer tw.Terminate()
gl.GetError() // Ignore error
debugContext.InitDebugContext()
world := generation.GenerateWorld(64, 64, 2)
gs := gamestate.NewGameState(window, world)
defer gs.Delete()
worldRenderer := rendering.NewWorldRenderer(window, gs.World)
defer worldRenderer.Delete()
gs.Bar.AddButton("screen shot", worldRenderer.ScreenShot, "")
MainLoop(gs, worldRenderer)
if *memprofile != "" {
f, err := os.Create(*memprofile)
if err != nil {
panic(err)
}
pprof.WriteHeapProfile(f)
f.Close()
return
}
}
