func main() {
if sdl.Init(sdl.INIT_VIDEO) < 0 {
panic("Video initialization failed: " + sdl.GetError())
}
if sdl.EnableKeyRepeat(100, 25) != 0 {
panic("Setting keyboard repeat failed: " + sdl.GetError())
}
videoFlags := sdl.OPENGL // Enable OpenGL in SDL
videoFlags |= sdl.DOUBLEBUF // Enable double buffering
videoFlags |= sdl.HWPALETTE // Store the palette in hardware
// FIXME: this causes segfault.
// videoFlags |= sdl.RESIZABLE // Enable window resizing
surface = sdl.SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, uint32(videoFlags))
if surface == nil {
panic("Video mode set failed: " + sdl.GetError())
}
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
initGL()
resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT)
SetupWorld("data/world.txt")
// wait for events
running := true
isActive := true
for running {
for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() {
switch e := ev.(type) {
case *sdl.ActiveEvent:
isActive = e.Gain != 0
case *sdl.ResizeEvent:
width, height := int(e.W), int(e.H)
surface = sdl.SetVideoMode(width, height, SCREEN_BPP, uint32(videoFlags))
if surface == nil {
fmt.Println("Could not get a surface after resize:", sdl.GetError())
Quit(1)
}
resizeWindow(width, height)
case *sdl.KeyboardEvent:
if e.Type == sdl.KEYDOWN {
handleKeyPress(e.Keysym)
}
case *sdl.QuitEvent:
running = false
}
}
// draw the scene
if isActive {
drawGLScene(sector1)
}
}
}
func main() {
globalState.Mouse = make(map[int]bool)
flag.Parse()
var err error
if sdl.Init(sdl.INIT_VIDEO) != 0 {
log.Printf("Unable to init SDL")
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 sdl.Quit()
screen := sdl.SetVideoMode(1024, 600, 32, sdl.OPENGL|sdl.RESIZABLE)
if screen == nil {
log.Printf("Unable to init sdl Screen")
}
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
initGL()
sdl.WM_SetCaption("sdlviewer", "sdlviewer")
running = true
for running {
handleInput()
drawScene()
}
}
func main() {
// Initialize SDL
if sdl.Init(sdl.INIT_VIDEO) < 0 {
panic("Video initialization failed: " + sdl.GetError())
}
// To avoid cramps
sdl.EnableKeyRepeat(250, 25)
// Sets up OpenGL double buffering
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
// flags to pass to sdl.SetVideoMode
videoFlags := sdl.OPENGL // Enable OpenGL in SDL
videoFlags |= sdl.DOUBLEBUF // Enable double buffering
videoFlags |= sdl.HWPALETTE // Store the palette in hardware
// FIXME: this causes segfault.
// videoFlags |= sdl.RESIZABLE // Enable window resizing
// get a SDL surface
surface = sdl.SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, uint32(videoFlags))
// verify there is a surface
if surface == nil {
panic("Video mode set failed: " + sdl.GetError())
Quit(1)
}
// When this function is finished, clean up and exit.
defer Quit(0)
LoadGLTextures("data/glass.bmp")
// Initialize OpenGL
initGL()
// Resize the initial window
resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT)
// wait for events
running := true
isActive := true
for running {
for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() {
switch e := ev.(type) {
case *sdl.ActiveEvent:
isActive = e.Gain != 0
case *sdl.ResizeEvent:
width, height := int(e.W), int(e.H)
surface = sdl.SetVideoMode(width, height, SCREEN_BPP, uint32(videoFlags))
if surface == nil {
fmt.Println("Could not get a surface after resize:", sdl.GetError())
Quit(1)
}
resizeWindow(width, height)
case *sdl.KeyboardEvent:
if e.Type == sdl.KEYDOWN {
handleKeyPress(e.Keysym)
}
case *sdl.QuitEvent:
running = false
}
}
// draw the scene
if isActive {
drawGLScene()
}
}
}
func main() {
runtime.LockOSThread()
flag.Parse()
buildPalette()
sdl.Init(sdl.INIT_VIDEO)
defer sdl.Quit()
sdl.GL_SetAttribute(sdl.GL_SWAP_CONTROL, 1)
if sdl.SetVideoMode(512, 512, 32, sdl.OPENGL) == nil {
panic("sdl error")
}
if gl.Init() != 0 {
panic("gl error")
}
sdl.WM_SetCaption("Gomandel", "Gomandel")
gl.Enable(gl.TEXTURE_2D)
gl.Viewport(0, 0, 512, 512)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, 512, 512, 0, -1, 1)
gl.ClearColor(0, 0, 0, 0)
//-----------------------------------------------------------------------------
var dndDragging bool = false
var dndStart Point
var dndEnd Point
var tex gl.Texture
var tc TexCoords
var lastProgress int
initialRect := Rect{-1.5, -1.5, 3, 3}
rect := initialRect
rc := new(MandelbrotRequest)
rc.MakeRequest(512, 512, rect)
rc.WaitFor(Small, &tex, &tc)
running := true
for running {
for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
switch e.(type) {
case *sdl.QuitEvent:
running = false
case *sdl.MouseButtonEvent:
mbe := e.(*sdl.MouseButtonEvent)
if mbe.Type == sdl.MOUSEBUTTONDOWN {
dndDragging = true
sdl.GetMouseState(&dndStart.X, &dndStart.Y)
dndEnd = dndStart
} else {
dndDragging = false
sdl.GetMouseState(&dndEnd.X, &dndEnd.Y)
if mbe.Which == 3 {
rect = initialRect
} else {
rect = rectFromSelection(dndStart, dndEnd, 512, 512, rect)
tc = texCoordsFromSelection(dndStart, dndEnd, 512, 512, tc)
}
// make request
rc.MakeRequest(512, 512, rect)
}
case *sdl.MouseMotionEvent:
if dndDragging {
sdl.GetMouseState(&dndEnd.X, &dndEnd.Y)
}
}
}
// if we're waiting for a result, check if it's ready
p := rc.Update(&tex, &tc)
if p != -1 {
lastProgress = p
}
gl.Clear(gl.COLOR_BUFFER_BIT)
tex.Bind(gl.TEXTURE_2D)
drawQuad(0, 0, 512, 512, tc.TX, tc.TY, tc.TX2, tc.TY2)
tex.Unbind(gl.TEXTURE_2D)
if dndDragging {
drawSelection(dndStart, dndEnd)
}
drawProgress(512, 512, lastProgress, rc.Pending)
sdl.GL_SwapBuffers()
}
}
func initGame() {
viewport.Zoomstd()
viewport.Rotx(25)
viewport.Roty(70)
picker = NewPicker()
sdl.Init(sdl.INIT_VIDEO)
if ttf.Init() != 0 {
panic("Could not initalize fonts")
}
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
screen := sdl.SetVideoMode(1024, 600, 32, sdl.OPENGL|sdl.RESIZABLE)
if screen == nil {
sdl.Quit()
panic("Couldn't set GL video mode: " + sdl.GetError() + "\n")
}
if gl.Init() != 0 {
panic("gl error")
}
sdl.WM_SetCaption("Amberfell", "amberfell")
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// gl.ShadeModel(gl.FLAT)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ShadeModel(gl.SMOOTH)
gl.Enable(gl.LIGHTING)
gl.Enable(gl.LIGHT0)
gl.Enable(gl.LIGHT1)
gl.Enable(gl.COLOR_MATERIAL)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearDepth(1.0) // Depth Buffer Setup
gl.Enable(gl.DEPTH_TEST) // Enables Depth Testing
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.FASTEST)
gl.Enable(gl.TEXTURE_2D)
// LoadMapTextures()
LoadPlayerTextures()
LoadWolfTextures()
InitItems()
pauseFont = NewFont("res/Jura-DemiBold.ttf", 48, color.RGBA{255, 255, 255, 0})
consoleFont = NewFont("res/Jura-DemiBold.ttf", 16, color.RGBA{255, 255, 255, 0})
inventoryItemFont = NewFont("res/Jura-DemiBold.ttf", 14, color.RGBA{240, 240, 240, 0})
textures[TEXTURE_PICKER] = loadTexture("res/dial.png")
terrainTexture = loadTexture("res/tiles.png")
itemsTexture = loadTexture("res/items.png")
gVertexBuffer = NewVertexBuffer(10000, terrainTexture)
gGuiBuffer = NewVertexBuffer(1000, terrainTexture)
WolfModel = LoadModel("res/wolf.mm3d")
TheWorld = NewWorld()
ThePlayer = new(Player)
ThePlayer.Init(0, PLAYER_START_X, PLAYER_START_Z)
inventory = NewInventory()
viewport.Reshape(int(screen.W), int(screen.H))
PreloadChunks(400)
}