func size_window(x, y int, fov, aspect, min_cull, max_cull float64) { gl.Viewport(0, 0, x, y) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() glu.Perspective(fov, aspect, min_cull, max_cull) gl.Enable(gl.DEPTH_TEST) }
func initScreen() { sdl.Init(sdl.INIT_VIDEO) const ( resx int = 640 resy int = 480 ) var ( screen = sdl.SetVideoMode(resx, resy, 16, sdl.OPENGL) ) if screen == nil { sdl.Quit() panic("Couldn't set GL video mode: " + sdl.GetError() + "\n") } if gl.Init() != 0 { panic("gl error") } gl.MatrixMode(gl.PROJECTION) //gl.MatrixMode(gl.MODELVIEW) gl.Viewport(0, 0, int(screen.W), int(screen.H)) gl.LoadIdentity() gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0) //gl.DepthRange(-1, 1) gl.ClearColor(0, 0, 0, 0) gl.Clear(gl.COLOR_BUFFER_BIT) }
func (this *Window) SetProjection2D() { gl.MatrixMode(gl.PROJECTION) gl.Viewport(0, 0, int(this.Width()), int(this.Height())) gl.LoadIdentity() gl.Ortho(0, float64(this.Width()), 0, float64(this.Height()), -1.0, 1.0) gl.MatrixMode(gl.MODELVIEW) }
/* new window size or exposure */ func (self *Viewport) Reshape(width int, height int) { self.selectionDirty = false self.screenWidth = width self.screenHeight = height gl.Viewport(0, 0, width, height) viewWidth := float64(self.screenWidth) / float64(SCREEN_SCALE) viewHeight := float64(self.screenHeight) / float64(SCREEN_SCALE) self.lplane = -viewWidth / 2 self.rplane = viewWidth / 2 self.bplane = -viewHeight / 4 self.tplane = 3 * viewHeight / 4 println("self.lplane:", self.lplane, "self.rplane", self.rplane) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(self.lplane, self.rplane, self.bplane, self.tplane, -60, 60) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() picker.x = float32(viewport.rplane) - picker.radius + blockscale*0.5 picker.y = float32(viewport.bplane) + picker.radius - blockscale*0.5 }
func (v *Video) Reshape(width int, height int) { x_offset := 0 y_offset := 0 r := ((float64)(height)) / ((float64)(width)) if r > 0.9375 { // Height taller than ratio h := (int)(math.Floor((float64)(0.9375 * (float64)(width)))) y_offset = (height - h) / 2 height = h } else if r < 0.9375 { // Width wider var scrW, scrH float64 if ppu.OverscanEnabled { scrW = 240.0 scrH = 224.0 } else { scrW = 256.0 scrH = 240.0 } w := (int)(math.Floor((float64)((scrH / scrW) * (float64)(height)))) x_offset = (width - w) / 2 width = w } gl.Viewport(x_offset, y_offset, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(-1, 1, -1, 1, -1, 1) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Disable(gl.DEPTH_TEST) }
// Handle the window being resized. func reshape(width int, height int) { // Render into the entire window. gl.Viewport(0, 0, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() // Configure the Frustrum so the front face of the rendering // volume fills the screen. w := float64(width) h := float64(height) depth := (w + h) / 2 near := depth / 2.0 right := w / 4.0 top := h / 4.0 far := 4 * depth gl.Frustum(-right, right, -top, top, near, far) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() // Center the rendering volume in the viewport. Its origin // is at the far lower left corner. gl.Translated(-w/2, -h/2, -2*depth) }
// reset our viewport after a window resize func resizeWindow(width, height int) { // protect against a divide by zero if height == 0 { height = 1 } // Setup our viewport gl.Viewport(0, 0, int(width), int(height)) // change to the projection matrix and set our viewing volume. gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() // aspect ratio aspect := gl.GLdouble(gl.GLfloat(width) / gl.GLfloat(height)) // Set our perspective. // This code is equivalent to using gluPerspective as in the original tutorial. var fov, near, far gl.GLdouble fov = 45.0 near = 0.1 far = 100.0 top := gl.GLdouble(math.Tan(float64(fov*math.Pi/360.0))) * near bottom := -top left := aspect * bottom right := aspect * top gl.Frustum(float64(left), float64(right), float64(bottom), float64(top), float64(near), float64(far)) // Make sure we're changing the model view and not the projection gl.MatrixMode(gl.MODELVIEW) // Reset the view gl.LoadIdentity() }
/* new window size or exposure */ func (self *Viewport) Reshape(width int, height int) { self.selectionDirty = false self.screenWidth = width self.screenHeight = height gl.Viewport(0, 0, width, height) viewWidth := float64(self.screenWidth) / float64(SCREEN_SCALE) viewHeight := float64(self.screenHeight) / float64(SCREEN_SCALE) self.lplane = -viewWidth / 2 self.rplane = viewWidth / 2 self.bplane = -viewHeight / 4 self.tplane = 3 * viewHeight / 4 gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(self.lplane, self.rplane, self.bplane, self.tplane, -60, 60) // self.Perspective(90, 1, 0.01,1000); gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() picker.x = float32(viewport.rplane) - picker.radius + BLOCK_SCALE*0.5 picker.y = float32(viewport.bplane) + picker.radius - BLOCK_SCALE*0.5 }
// Initialize the OpenGL configuration with the information from the current window. func InitGLWindow(w, h int) { gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() glu.Perspective(45.0, float64(w)/float64(h), 0.1, 100.0) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() }
func reshape(w, h int) { gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(0, float64(w), 0, float64(h), -1, 1) gl.Scalef(1, -1, 1) gl.Translatef(0, float32(-h), 0) gl.MatrixMode(gl.MODELVIEW) }
func onResize(w, h int) { gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Viewport(0, 0, w, h) gl.Ortho(0, float64(w), float64(h), 0, -1.0, 1.0) gl.ClearColor(1, 1, 1, 0) gl.Clear(gl.COLOR_BUFFER_BIT) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() }
/* new window size or exposure */ func reshape(width int, height int) { h := float64(height) / float64(width) gl.Viewport(0, 0, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Frustum(-1.0, 1.0, -h, h, 5.0, 60.0) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Translatef(0.0, 0.0, -40.0) }
func onResize(w, h int) { if h == 0 { h = 1 } gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() glu.Perspective(45.0, float64(w)/float64(h), 0.1, 100.0) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() }
func main() { sdl.Init(sdl.INIT_VIDEO) var screen = sdl.SetVideoMode(640, 480, 32, sdl.OPENGL) if screen == nil { panic("sdl error") } if gl.Init() != 0 { panic("gl error") } pen := Pen{} gl.MatrixMode(gl.PROJECTION) gl.Viewport(0, 0, int(screen.W), int(screen.H)) gl.LoadIdentity() gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0) gl.ClearColor(1, 1, 1, 0) gl.Clear(gl.COLOR_BUFFER_BIT) var running = true for running { for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() { switch ev := e.(type) { case *sdl.QuitEvent: running = false case *sdl.KeyboardEvent: if ev.Keysym.Sym == sdl.K_ESCAPE { running = false } case *sdl.MouseMotionEvent: if ev.State != 0 { pen.lineTo(Point{int(ev.X), int(ev.Y)}) } else { pen.moveTo(Point{int(ev.X), int(ev.Y)}) } } } sdl.GL_SwapBuffers() sdl.Delay(25) } sdl.Quit() }
func onResize(w, h int) { if h == 0 { h = 1 } gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(-1, 1, -1, 1, -1, 1) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Disable(gl.DEPTH_TEST) }
func (this *Window) reshape(w, h int) { gl.Viewport(0, 0, w, h) ratio := Double(w) / Double(h) var znear, zfar, fovx Double = 0.01, 65536.0, 80.0 this.projectionMatrix = mat4.Projection(fovx.ToRad(), ratio, znear, zfar) if globals.UseShader { program.SetProjectionMatrix(this.projectionMatrix) program.SetFarClipplane(zfar) } gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.LoadMatrixd(this.projectionMatrix.Ptr()) gl.MatrixMode(gl.MODELVIEW) }
func reshape(w, h int) { /* Because Gil specified "screen coordinates" (presumably with an upper-left origin), this short bit of code sets up the coordinate system to correspond to actual window coodrinates. This code wouldn't be required if you chose a (more typical in 3D) abstract coordinate system. */ gl.Viewport(0, 0, w, h) /* Establish viewing area to cover entire window. */ gl.MatrixMode(gl.PROJECTION) /* Start modifying the projection matrix. */ gl.LoadIdentity() /* Reset project matrix. */ gl.Ortho(0, float64(w), 0, float64(h), -1, 1) /* Map abstract coords directly to window coords. */ gl.Scalef(1, -1, 1) /* Invert Y axis so increasing Y goes down. */ gl.Translatef(0, float32(-h), 0) /* Shift origin up to upper-left corner. */ }
func (this *Window) reshape(w, h int) { gl.Viewport(0, 0, w, h) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() ratio := float64(w) / float64(h) znear, zfar, fovx := 0.01, 65536.0, 80.0 /*var top, bottom, left, right float64 right = znear * math.Tan(DegToRad(.5*fovx)) left = -right top = right/ratio bottom = -top gl.Frustum(left,right,bottom,top,znear, zfar)//*/ this.projectionMatrix = mat4.Projection(DegToRad(fovx), ratio, znear, zfar) gl.LoadMatrixd(this.projectionMatrix.Ptr()) gl.MatrixMode(gl.MODELVIEW) }
func initGl() { h := float64(height) / float64(width) gl.Viewport(0, 0, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Frustum(-1.0, 1.0, -h, h, 5.0, 60.0) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Translatef(0.0, 0.0, -6.0) gl.EnableClientState(gl.VERTEX_ARRAY) gl.EnableClientState(gl.TEXTURE_COORD_ARRAY) gl.VertexPointer(3, 0, &vertices[0][0]) gl.TexCoordPointer(2, 0, &texCoords[0][0]) }
func InitUI() *UI { ui := &UI{ running: false, } if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } if ttf.Init() != 0 { panic(sdl.GetError()) } ui.screen = sdl.SetVideoMode(300, 300, 32, sdl.OPENGL) if ui.screen == nil { panic("sdl error") } if gl.Init() != 0 { panic("gl error") } gl.MatrixMode(gl.PROJECTION) gl.Viewport(0, 0, int(ui.screen.W), int(ui.screen.H)) gl.LoadIdentity() gl.Ortho(0, float64(ui.screen.W), float64(ui.screen.H), 0, -1.0, 1.0) gl.ClearColor(1, 1, 1, 0) gl.Clear(gl.COLOR_BUFFER_BIT) // TTF sdl.EnableUNICODE(1) ui.font = ttf.OpenFont("FontinSans.otf", 20) ui.font.SetStyle(ttf.STYLE_UNDERLINE) if ui.font == nil { panic(sdl.GetError()) } ui.running = true return ui }
func onResize(w, h int) { if h == 0 { h = 1 } gl.Viewport(0, 0, w, h) scale := math.Min(float64(w)/640.0, float64(h)/480.0) hw := float64(w) * (0.5 / scale) hh := float64(h) * (0.5 / scale) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(-hw, hw, -hh, hh, -1.0, 1.0) gl.Translated(0.5, 0.5, 0.0) Width = w Height = h }
func setup_opengl(width, height int) { ratio := float64(width) / float64(height) gl.ShadeModel(gl.SMOOTH) gl.CullFace(gl.BACK) gl.FrontFace(gl.CCW) gl.Enable(gl.CULL_FACE) gl.ClearColor(0, 0, 0, 0) gl.Viewport(0, 0, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gluPerspective := func(fovy, aspect, zNear, zFar float64) { top := math.Tan(fovy*0.5) * zNear bottom := -top left := aspect * bottom right := -left gl.Frustum(left, right, bottom, top, zNear, zFar) } gluPerspective(60.0, ratio, 1.0, 1024.0) }
func reshape(width int, height int) { x_offset := 0 y_offset := 0 r := ((float64)(height)) / ((float64)(width)) if r > 0.9375 { // Height taller than ratio h := (int)(math.Floor((float64)(0.9375 * (float64)(width)))) y_offset = (height - h) / 2 height = h } else if r < 0.9375 { // Width wider w := (int)(math.Floor((float64)((256.0 / 240.0) * (float64)(height)))) x_offset = (width - w) / 2 width = w } gl.Viewport(x_offset, y_offset, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(-1, 1, -1, 1, -1, 1) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Disable(gl.DEPTH_TEST) }
func reshape(width, height int) { shift, aspect := 0, float64(width)/float64(height) if aspect > 2 { aspect = 2 shift = width/2 - height width = height * 2 } gl.Viewport(shift, 0, width, height) gl.Enable(gl.DEPTH_TEST) gl.Enable(gl.COLOR_MATERIAL) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() glu.Perspective(45, aspect, NEAR_Z, FAR_Z) gl.Enable(gl.LIGHTING) gl.Lightfv(gl.LIGHT0, gl.POSITION, []float32{-2, -3, 5, 0}) gl.Lightfv(gl.LIGHT0, gl.AMBIENT, []float32{0.1, 0.1, 0.2, 1}) gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, []float32{0.4, 0.35, 0.2, 1}) gl.Lightfv(gl.LIGHT0, gl.SPECULAR, []float32{1, 1, 1, 1}) gl.Enable(gl.LIGHT0) gl.Rotatef(-30, 1, 0, 0) gl.Translatef(0, 0, -5) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Lightfv(gl.LIGHT1, gl.AMBIENT, []float32{0, 0, 0, 1}) gl.Lightfv(gl.LIGHT1, gl.DIFFUSE, []float32{0.4, 0.4, 0.4, 1}) gl.Lightfv(gl.LIGHT1, gl.SPECULAR, []float32{1, 1, 1, 1}) gl.Enable(gl.LIGHT1) }
func main() { runtime.LockOSThread() flag.Parse() sdl.Init(sdl.INIT_VIDEO) defer sdl.Quit() sdl.GL_SetAttribute(sdl.GL_SWAP_CONTROL, 1) if sdl.SetVideoMode(640, 480, 32, sdl.OPENGL) == nil { panic("sdl error") } sdl.WM_SetCaption("Gotris", "Gotris") sdl.EnableKeyRepeat(250, 45) gl.Enable(gl.TEXTURE_2D) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.Viewport(0, 0, 640, 480) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(0, 640, 480, 0, -1, 1) gl.ClearColor(0, 0, 0, 0) //----------------------------------------------------------------------------- font, err := LoadFontFromFile("dejavu.font") if err != nil { panic(err) } rand.Seed(int64(sdl.GetTicks())) gs := NewGameSession(*initLevel, font) lastTime := sdl.GetTicks() ticker := time.NewTicker(10 * time.Millisecond) stop := make(chan byte, 1) go func() { for { switch e := (<-sdl.Events).(type) { case sdl.QuitEvent: stop <- 0 case sdl.KeyboardEvent: if e.Type == sdl.KEYDOWN { running := gs.HandleKey(e.Keysym.Sym) if !running { stop <- 0 } gs.update <- 0 } } } }() loop: for { select { case <-ticker.C: gs.update <- 0 case <-gs.update: now := sdl.GetTicks() delta := now - lastTime lastTime = now gs.Update(delta) gl.Clear(gl.COLOR_BUFFER_BIT) font.Draw(5, 5, fmt.Sprintf("Level: %d | Score: %d", gs.Level, gs.Score)) gs.Draw() gl.Color3ub(255, 255, 255) sdl.GL_SwapBuffers() case <-stop: break loop } } }
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) gl.BindTexture(gl.TEXTURE_2D, 0) if dndDragging { drawSelection(dndStart, dndEnd) } drawProgress(512, 512, lastProgress, rc.Pending) sdl.GL_SwapBuffers() } }
func main() { runtime.LockOSThread() if sdl.Init(sdl.INIT_EVERYTHING) != 0 { log.Fatal(sdl.GetError()) } var screen = sdl.SetVideoMode(screenWidth, screenHeight, 32, sdl.OPENGL|sdl.HWSURFACE|sdl.GL_DOUBLEBUFFER|sdl.FULLSCREEN) if screen == nil { log.Fatal(sdl.GetError()) } sdl.WM_SetCaption("Lecture Hall Games", "") sdl.EnableUNICODE(1) if gl.Init() != 0 { log.Fatal("could not initialize OpenGL") } gl.Viewport(0, 0, int(screen.W), int(screen.H)) gl.ClearColor(1, 1, 1, 0) gl.Clear(gl.COLOR_BUFFER_BIT) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0) gl.Disable(gl.LIGHTING) gl.Disable(gl.DEPTH_TEST) gl.TexEnvi(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.MODULATE) if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT, mixer.DEFAULT_CHANNELS, 4096) != 0 { log.Fatal(sdl.GetError()) } if ttf.Init() != 0 { log.Fatal(sdl.GetError()) } if p, err := build.Default.Import(basePkg, "", build.FindOnly); err == nil { os.Chdir(p.Dir) } var err error rand.Seed(time.Now().UnixNano()) levelDir := fmt.Sprintf("data/levels/demolevel%d", 3+rand.Intn(numberLevels)) //carsDir := fmt.Sprintf(" data/cars/car%d/", 1+rand.Intn(numberCars)) if game, err = NewRacer(levelDir); err != nil { log.Fatal(err) } go func() { listen, err := net.Listen("tcp", ":8001") if err != nil { log.Fatal(err) } for { conn, err := listen.Accept() if err != nil { log.Println(err) continue } go handleConnection(conn) } }() running := true last := time.Now() for running { select { case event := <-sdl.Events: switch e := event.(type) { case sdl.QuitEvent: running = false case sdl.ResizeEvent: screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE) case sdl.KeyboardEvent: if e.Type == sdl.KEYDOWN { if e.Keysym.Sym == sdl.K_ESCAPE { running = false } else { game.KeyPressed(e.Keysym) } } } default: } current := time.Now() t := current.Sub(last) last = current mu.Lock() game.Update(t) game.Render(screen) mu.Unlock() sdl.GL_SwapBuffers() } sdl.Quit() }