func (gw *GameWindow) Draw(region gui.Region, style gui.StyleStack) { defer base.StackCatcher() defer func() { // gl.Translated(gl.Double(gw.region.X), gl.Double(gw.region.Y), 0) gl.Disable(gl.TEXTURE_2D) gl.Color4ub(255, 255, 255, 255) gl.LineWidth(3) gl.Begin(gl.LINES) bx, by := gl.Int(region.X), gl.Int(region.Y) bdx, bdy := gl.Int(region.Dx), gl.Int(region.Dy) gl.Vertex2i(bx, by) gl.Vertex2i(bx, by+bdy) gl.Vertex2i(bx, by+bdy) gl.Vertex2i(bx+bdx, by+bdy) gl.Vertex2i(bx+bdx, by+bdy) gl.Vertex2i(bx+bdx, by) gl.Vertex2i(bx+bdx, by) gl.Vertex2i(bx, by) gl.End() gl.LineWidth(1) }() gw.Engine.Pause() game := gw.Engine.GetState().(*Game) game.RenderLocal(region, gw.Local) gw.Engine.Unpause() }
func (gw *GameWindow) Draw(region g2.Region, style g2.StyleStack) { defer base.StackCatcher() defer func() { // gl.Translated(gl.Double(gw.region.X), gl.Double(gw.region.Y), 0) gl.Disable(gl.TEXTURE_2D) gl.Color4ub(255, 255, 255, 255) gl.LineWidth(3) gl.Begin(gl.LINES) bx, by := gl.Int(region.X), gl.Int(region.Y) bdx, bdy := gl.Int(region.Dx), gl.Int(region.Dy) gl.Vertex2i(bx, by) gl.Vertex2i(bx, by+bdy) gl.Vertex2i(bx, by+bdy) gl.Vertex2i(bx+bdx, by+bdy) gl.Vertex2i(bx+bdx, by+bdy) gl.Vertex2i(bx+bdx, by) gl.Vertex2i(bx+bdx, by) gl.Vertex2i(bx, by) gl.End() gl.LineWidth(1) }() gw.Engine.Pause() game := gw.Engine.GetState().(*Game) // Note that since we do a READER lock on game.local we cannot do any writes // to local data while rendering. game.local.RLock() game.RenderLocal(region) game.local.RUnlock() gw.Engine.Unpause() }
func (vb *VertexBuffer) Render(position Point3) { gl.PushMatrix() gl.Translated( gl.Double(position.X), gl.Double(position.Y), gl.Double(position.Z)) gl.VertexPointer( gl.Int(3), gl.DOUBLE, 0, gl.Pointer(&vb.VertexData[0])) gl.ColorPointer( gl.Int(4), gl.DOUBLE, 0, gl.Pointer(&vb.ColorData[0])) gl.TexCoordPointer( gl.Int(2), gl.DOUBLE, 0, gl.Pointer(&vb.TexCoordData[0])) for i := range vb.RenderSteps { rs := &vb.RenderSteps[i] gl.DrawElements( rs.Mode, gl.Sizei(len(rs.Indices)), gl.UNSIGNED_INT, gl.Pointer(&rs.Indices[0])) } gl.PopMatrix() }
func (tsm *ThunderSubMenu) Draw(region Region, style StyleStack) { gl.Disable(gl.TEXTURE_2D) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.Enable(gl.BLEND) base.EnableShader("marble") offset, ok := style.Get("offset").(linear.Vec2) if ok { base.SetUniformV2("marble", "offset", offset) } else { base.SetUniformV2("marble", "offset", linear.Vec2{}) } gl.Color4ub(255, 255, 255, 255) gl.Begin(gl.QUADS) x := gl.Int(region.X) y := gl.Int(region.Y) dx := gl.Int(region.Dx) dy := gl.Int(region.Dy) gl.Vertex2i(x, y) gl.Vertex2i(x, y+dy) gl.Vertex2i(x+dx, y+dy) gl.Vertex2i(x+dx, y) gl.End() base.EnableShader("") for i, option := range tsm.Options { region.Dy = tsm.requests[option].Dy if i == tsm.selected { style.PushStyle(map[string]interface{}{"selected": true}) } else { style.PushStyle(map[string]interface{}{"selected": false}) } option.Draw(region, style) style.Pop() region.Y += tsm.requests[option].Dy } }
func (g *Game) RenderLocalEditor(region g2.Region) { g.editor.Lock() defer g.editor.Unlock() g.editor.region = region g.editor.camera.regionDims = linear.Vec2{float64(region.Dims.Dx), float64(region.Dims.Dy)} levelDims := linear.Vec2{float64(g.Level.Room.Dx), float64(g.Level.Room.Dy)} g.editor.camera.StandardRegion(levelDims.Scale(0.5), levelDims) g.editor.camera.approachTarget() gl.MatrixMode(gl.PROJECTION) gl.PushMatrix() gl.LoadIdentity() defer gl.PopMatrix() gl.PushAttrib(gl.VIEWPORT_BIT) gl.Viewport(gl.Int(region.X), gl.Int(region.Y), gl.Sizei(region.Dx), gl.Sizei(region.Dy)) defer gl.PopAttrib() current := &g.editor.camera.current gl.Ortho( gl.Double(current.mid.X-current.dims.X/2), gl.Double(current.mid.X+current.dims.X/2), gl.Double(current.mid.Y+current.dims.Y/2), gl.Double(current.mid.Y-current.dims.Y/2), gl.Double(1000), gl.Double(-1000), ) defer func() { gl.MatrixMode(gl.PROJECTION) gl.PopMatrix() gl.MatrixMode(gl.MODELVIEW) }() gl.MatrixMode(gl.MODELVIEW) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) g.renderWalls() g.renderEdges() g.renderBases() g.renderEntsAndAbilities() g.renderProcesses() g.editor.renderPathing(&g.Level.Room, g.local.pathingData) switch g.editor.action { case editorActionNone: case editorActionPlaceBlock: g.editor.renderPlaceBlock(g) default: base.Error().Printf("Unexpected editorAction: %v", g.editor.action) } }
// SetVariable4i sets a specified variable to the four supplied integers to be // passed into an effect. func (effect *Effect) SetVariable4i(variable string, val1 int, val2 int, val3 int, val4 int) error { var currEffect gl.Int gl.GetIntegerv(gl.CURRENT_PROGRAM, &currEffect) if gl.Uint(currEffect) != effect.program { return errors.New("effect is not currently in use") } effect.checkUniformVariable(variable) gl.Uniform4i(effect.uniforms[variable], gl.Int(val1), gl.Int(val2), gl.Int(val3), gl.Int(val4)) return nil }
func shinit() gl.Int { vs := loadShader(gl.VERTEX_SHADER, vss) var sfs string if *blend { sfs = bfss } else { sfs = fss } fs := loadShader(gl.FRAGMENT_SHADER, sfs) prg := gl.CreateProgram() gl.AttachShader(prg, vs) gl.AttachShader(prg, fs) gl.LinkProgram(prg) var l int if *blend { l = 6 } else { l = 3 } gl.UseProgram(prg) names := []string{"yt1", "cbt1", "crt1", "yt0", "cbt0", "crt0"} for i := 0; i < l; i++ { loc := gl.GetUniformLocation(prg, gl.GLString(names[i])) gl.Uniform1i(loc, gl.Int(i)) } return gl.GetUniformLocation(prg, gl.GLString("factor")) }
func (c *Console) DrawFocused(region gui.Region) { gl.Color4d(0.2, 0, 0.3, 0.8) gl.Disable(gl.TEXTURE_2D) gl.Begin(gl.QUADS) { x := gl.Int(region.X) y := gl.Int(region.Y) x2 := gl.Int(region.X + region.Dx) y2 := gl.Int(region.Y + region.Dy) gl.Vertex2i(x, y) gl.Vertex2i(x, y2) gl.Vertex2i(x2, y2) gl.Vertex2i(x2, y) } gl.End() gl.Color4d(1, 1, 1, 1) y := float64(region.Y) + float64(len(c.lines))*lineHeight do_color := func(line string) { if strings.HasPrefix(line, "LOG") { gl.Color4d(1, 1, 1, 1) } if strings.HasPrefix(line, "WARN") { gl.Color4d(1, 1, 0, 1) } if strings.HasPrefix(line, "ERROR") { gl.Color4d(1, 0, 0, 1) } } if c.start > c.end { for i := c.start; i < len(c.lines); i++ { do_color(c.lines[i]) c.dict.RenderString(c.lines[i], c.xscroll, y, 0, lineHeight, gui.Left) y -= lineHeight } for i := 0; i < c.end; i++ { do_color(c.lines[i]) c.dict.RenderString(c.lines[i], c.xscroll, y, 0, lineHeight, gui.Left) y -= lineHeight } } else { for i := c.start; i < c.end && i < len(c.lines); i++ { do_color(c.lines[i]) c.dict.RenderString(c.lines[i], c.xscroll, y, 0, lineHeight, gui.Left) y -= lineHeight } } }
func (p *PosWidget) Draw(region Region, style StyleStack) { gl.Disable(gl.TEXTURE_2D) gl.Color4ub(0, 255, 0, 255) gl.Begin(gl.QUADS) x := gl.Int(region.X) y := gl.Int(region.Y) dx := gl.Int(base.GetDictionary("luxisr").StringWidth(p.text, float64(p.Size))) dy := gl.Int(p.Size) gl.Vertex2i(x, y) gl.Vertex2i(x, y+dy) gl.Vertex2i(x+dx, y+dy) gl.Vertex2i(x+dx, y) gl.End() base.Log().Printf("%v %v %v %v", x, y, dx, dy) gl.Color4ub(255, 0, 255, 255) base.GetDictionary("luxisr").RenderString(p.text, float64(region.X), float64(region.Y), 0, float64(p.Size), gui.Left) }
func upload(id gl.Uint, data []byte, stride int, w int, h int) { gl.BindTexture(gl.TEXTURE_2D, id) gl.PixelStorei(gl.UNPACK_ROW_LENGTH, gl.Int(stride)) gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1) gl.TexImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, gl.Sizei(w), gl.Sizei(h), 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, gl.Pointer(&data[0])) }
func (g *Game) renderLosMask(local *LocalData) { ent := g.Ents[local.moba.currentPlayer.gid] if ent == nil { return } walls := g.temp.VisibleWallCache[GidInvadersStart].GetWalls(int(ent.Pos().X), int(ent.Pos().Y)) gl.Disable(gl.TEXTURE_2D) gl.Color4ub(0, 0, 0, 255) gl.Begin(gl.TRIANGLES) for _, wall := range walls { if wall.Right(ent.Pos()) { continue } a := wall.P b := ent.Pos().Sub(wall.P).Norm().Scale(-10000.0).Add(wall.P) mid := wall.P.Add(wall.Q).Scale(0.5) c := ent.Pos().Sub(mid).Norm().Scale(-10000.0).Add(mid) d := ent.Pos().Sub(wall.Q).Norm().Scale(-10000.0).Add(wall.Q) e := wall.Q gl.Vertex2d(gl.Double(a.X), gl.Double(a.Y)) gl.Vertex2d(gl.Double(b.X), gl.Double(b.Y)) gl.Vertex2d(gl.Double(c.X), gl.Double(c.Y)) gl.Vertex2d(gl.Double(a.X), gl.Double(a.Y)) gl.Vertex2d(gl.Double(c.X), gl.Double(c.Y)) gl.Vertex2d(gl.Double(d.X), gl.Double(d.Y)) gl.Vertex2d(gl.Double(a.X), gl.Double(a.Y)) gl.Vertex2d(gl.Double(d.X), gl.Double(d.Y)) gl.Vertex2d(gl.Double(e.X), gl.Double(e.Y)) } gl.End() base.EnableShader("horizon") base.SetUniformV2("horizon", "center", ent.Pos()) base.SetUniformF("horizon", "horizon", LosMaxDist) gl.Begin(gl.QUADS) dx := gl.Int(g.Levels[GidInvadersStart].Room.Dx) dy := gl.Int(g.Levels[GidInvadersStart].Room.Dy) gl.Vertex2i(0, 0) gl.Vertex2i(dx, 0) gl.Vertex2i(dx, dy) gl.Vertex2i(0, dy) gl.End() base.EnableShader("") }
func (g *Game) RenderLocalGame(region g2.Region) { g.local.Camera.regionDims = linear.Vec2{float64(region.Dims.Dx), float64(region.Dims.Dy)} // func (g *Game) renderLocalHelper(region g2.Region, local *LocalData, camera *cameraInfo, side int) { g.local.Camera.FocusRegion(g, 0) gl.MatrixMode(gl.PROJECTION) gl.PushMatrix() gl.LoadIdentity() // Set the viewport so that we only render into the region that we're supposed // to render to. // TODO: Check if this works on all graphics cards - I've heard that the opengl // spec doesn't actually require that viewport does any clipping. gl.PushAttrib(gl.VIEWPORT_BIT) gl.Viewport(gl.Int(region.X), gl.Int(region.Y), gl.Sizei(region.Dx), gl.Sizei(region.Dy)) defer gl.PopAttrib() current := &g.local.Camera.current gl.Ortho( gl.Double(current.mid.X-current.dims.X/2), gl.Double(current.mid.X+current.dims.X/2), gl.Double(current.mid.Y+current.dims.Y/2), gl.Double(current.mid.Y-current.dims.Y/2), gl.Double(1000), gl.Double(-1000), ) defer func() { gl.MatrixMode(gl.PROJECTION) gl.PopMatrix() gl.MatrixMode(gl.MODELVIEW) }() gl.MatrixMode(gl.MODELVIEW) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) level := g.Level zoom := current.dims.X / float64(region.Dims.Dx) level.ManaSource.Draw(zoom, float64(level.Room.Dx), float64(level.Room.Dy)) g.renderWalls() g.renderEdges() g.renderBases() g.renderEntsAndAbilities() g.renderProcesses() g.RenderLosMask() }
func SetUniformI(shader, variable string, n int) error { prog, ok := shader_progs[shader] if !ok { return shaderError(fmt.Sprintf("Tried to set a uniform in an unknown shader '%s'", shader)) } bvariable := []byte(fmt.Sprintf("%s\x00", variable)) loc := gl.GetUniformLocation(prog, (*gl.Char)(unsafe.Pointer(&bvariable[0]))) gl.Uniform1i(loc, gl.Int(n)) return nil }
func (b *Box) Draw(region Region, style StyleStack) { b.Last = region gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.Disable(gl.TEXTURE_2D) if b.Hover { gl.Color4ub(gl.Ubyte(b.Color[0]), gl.Ubyte(b.Color[1]), gl.Ubyte(b.Color[2]), gl.Ubyte(b.Color[3])) } else { gl.Color4ub(gl.Ubyte(b.Color[0]), gl.Ubyte(b.Color[1]), gl.Ubyte(b.Color[2]), gl.Ubyte(b.Color[3])/2) } gl.Begin(gl.QUADS) x := gl.Int(region.X) y := gl.Int(region.Y) dx := gl.Int(region.Dx) dy := gl.Int(region.Dy) gl.Vertex2i(x, y) gl.Vertex2i(x+dx, y) gl.Vertex2i(x+dx, y+dy) gl.Vertex2i(x, y+dy) gl.End() }
func SetUniformI(shader, variable string, n int) { prog, ok := shader_progs[shader] if !ok { if !warned_names[shader] { Warn().Printf("Tried to set a uniform in an unknown shader '%s'", shader) warned_names[shader] = true } return } bvariable := []byte(fmt.Sprintf("%s\x00", variable)) loc := gl.GetUniformLocation(prog, (*gl.Char)(unsafe.Pointer(&bvariable[0]))) gl.Uniform1i(loc, gl.Int(n)) }
func RegisterShader(name string, vertex, fragment []byte) error { if _, ok := shader_progs[name]; ok { return shaderError(fmt.Sprintf("Tried to register a shader called '%s' twice", name)) } vertex_id := gl.CreateShader(gl.VERTEX_SHADER) pointer := &vertex[0] length := gl.Int(len(vertex)) gl.ShaderSource(vertex_id, 1, (**gl.Char)(unsafe.Pointer(&pointer)), &length) gl.CompileShader(vertex_id) var param gl.Int gl.GetShaderiv(vertex_id, gl.COMPILE_STATUS, ¶m) if param == 0 { return shaderError(fmt.Sprintf("Failed to compile vertex shader '%s': %v", name, param)) } fragment_id := gl.CreateShader(gl.FRAGMENT_SHADER) pointer = &fragment[0] length = gl.Int(len(fragment)) gl.ShaderSource(fragment_id, 1, (**gl.Char)(unsafe.Pointer(&pointer)), &length) gl.CompileShader(fragment_id) gl.GetShaderiv(fragment_id, gl.COMPILE_STATUS, ¶m) if param == 0 { return shaderError(fmt.Sprintf("Failed to compile fragment shader '%s': %v", name, param)) } // shader successfully compiled - now link program_id := gl.CreateProgram() gl.AttachShader(program_id, vertex_id) gl.AttachShader(program_id, fragment_id) gl.LinkProgram(program_id) gl.GetProgramiv(program_id, gl.LINK_STATUS, ¶m) if param == 0 { return shaderError(fmt.Sprintf("Failed to link shader '%s': %v", name, param)) } shader_progs[name] = program_id return nil }
func (c *Console) Draw(x, y, dx, dy int) { if !gin.In().GetKeyFlat(gin.EitherShift, gin.DeviceTypeAny, gin.DeviceIndexAny).IsDown() { return } c.tail.GetLines(c.lines) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.Color4d(0.2, 0, 0.3, 0.8) gl.Disable(gl.TEXTURE_2D) gl.Begin(gl.QUADS) { glx := gl.Int(x) gly := gl.Int(y) glx2 := gl.Int(x + dx) gly2 := gl.Int(y + dy) gl.Vertex2i(glx, gly) gl.Vertex2i(glx, gly2) gl.Vertex2i(glx2, gly2) gl.Vertex2i(glx2, gly) } gl.End() gui.SetFontColor(1, 1, 1, 1) startY := float64(y + dy - len(c.lines)*lineHeight) for i, line := range c.lines { switch { case strings.HasPrefix(line, "LOG"): gui.SetFontColor(1, 1, 1, 1) case strings.HasPrefix(line, "WARN"): gui.SetFontColor(1, 1, 0, 1) case strings.HasPrefix(line, "ERROR"): gui.SetFontColor(1, 0, 0, 1) default: gui.SetFontColor(1, 1, 1, 0.7) } c.dict.RenderString(line, float64(x), startY+float64(i*lineHeight), 0, lineHeight, gui.Left) } }
func (c *Console) Draw(region Region, stlye StyleStack) { if !c.visible { return } gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.Color4d(0.2, 0, 0.3, 0.8) gl.Disable(gl.TEXTURE_2D) gl.Begin(gl.QUADS) { x := gl.Int(region.X) y := gl.Int(region.Y) x2 := gl.Int(region.X + region.Dx) y2 := gl.Int(region.Y + region.Dy) gl.Vertex2i(x, y) gl.Vertex2i(x, y2) gl.Vertex2i(x2, y2) gl.Vertex2i(x2, y) } gl.End() gui.SetFontColor(1, 1, 1, 1) startY := float64(region.Y + region.Dy - len(c.lines)*lineHeight) for i, line := range c.lines { switch { case strings.HasPrefix(line, "LOG"): gui.SetFontColor(1, 1, 1, 1) case strings.HasPrefix(line, "WARN"): gui.SetFontColor(1, 1, 0, 1) case strings.HasPrefix(line, "ERROR"): gui.SetFontColor(1, 0, 0, 1) default: gui.SetFontColor(1, 1, 1, 0.7) } c.dict.RenderString(line, float64(region.X), startY+float64(i*lineHeight), 0, lineHeight, gui.Left) } }
func drawQuad(x, y, w, h int, u, v, u2, v2 float32) { gl.Begin(gl.QUADS) gl.TexCoord2f(gl.Float(u), gl.Float(v)) gl.Vertex2i(gl.Int(x), gl.Int(y)) gl.TexCoord2f(gl.Float(u2), gl.Float(v)) gl.Vertex2i(gl.Int(x+w), gl.Int(y)) gl.TexCoord2f(gl.Float(u2), gl.Float(v2)) gl.Vertex2i(gl.Int(x+w), gl.Int(y+h)) gl.TexCoord2f(gl.Float(u), gl.Float(v2)) gl.Vertex2i(gl.Int(x), gl.Int(y+h)) gl.End() }
func makeBallVertexBuffer() VertexBuffer { vb := VertexBuffer{} points := []Point3{} colors := []Color{} texCoords := [][2]float64{} indices := []gl.Int{} for i := 0; i < 20; i++ { theta := (2 * math.Pi) * (float64(i) / 20.0) points = append(points, Point3{ Config.BallRadius * math.Cos(theta), Config.BallRadius * math.Sin(theta), 0}) colors = append(colors, Black) texCoords = append(texCoords, [2]float64{0, 0}) indices = append(indices, gl.Int(i)) } vb.InitVertexData(points, colors, texCoords) renderStep := VertexBufferRenderStep{gl.LINE_LOOP, indices} vb.RenderSteps = []VertexBufferRenderStep{renderStep} return vb }
func MakeLevelVertexBuffer(lb *LevelBlueprint) *VertexBuffer { vb := VertexBuffer{} points := []Point3{} colors := []Color{} texCoords := [][2]float64{} for wi := range lb.Walls { indices := []gl.Int{} for vi := range lb.Walls[wi].Vertices { points = append( points, lb.Walls[wi].Vertices[vi].Position) colors = append(colors, lb.Walls[wi].Vertices[vi].Color) texCoords = append( texCoords, [2]float64{lb.Walls[wi].Vertices[vi].Tu, lb.Walls[wi].Vertices[vi].Tv}) indices = append(indices, gl.Int(len(points)-1)) } renderStep := VertexBufferRenderStep{gl.TRIANGLE_FAN, indices} vb.RenderSteps = append(vb.RenderSteps, renderStep) } vb.InitVertexData(points, colors, texCoords) return &vb }
func main() { runtime.LockOSThread() flag.Parse() if *workers <= 0 { *workers = 1 } runtime.GOMAXPROCS(*workers + 1) buildPalette() sdl.Init(sdl.INIT_VIDEO) defer sdl.Quit() if !*noVSync { sdl.GL_SetAttribute(sdl.GL_SWAP_CONTROL, 1) } if sdl.SetVideoMode(512, 512, 32, sdl.OPENGL) == nil { panic("sdl error") } sdl.WM_SetCaption("Gomandel", "Gomandel") if err := gl.Init(); err != nil { panic(err) } 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 dnd3 bool = false var dndStart Point var dndEnd Point initialRect := Rect{-1.5, -1.5, 3, 3} rect := initialRect tm := NewTileManager(512, 512) tm.ZoomRequest(&rect) running := true for running { for { var event interface{} select { case event = <-sdl.Events: default: } if event == nil { break } switch e := event.(type) { case sdl.QuitEvent: running = false case sdl.MouseButtonEvent: if e.Type == sdl.MOUSEBUTTONDOWN { dndDragging = true dndStart.X = gl.Int(e.X) dndStart.Y = gl.Int(e.Y) dndEnd = dndStart if e.Button == 3 { dnd3 = true } else { dndDragging = true } } else { dndDragging = false dndEnd.X = gl.Int(e.X) dndEnd.Y = gl.Int(e.Y) switch e.Button { case 1: rect = rectFromSelection(dndStart, dndEnd, 512, 512, rect) tm.ZoomRequest(&rect) case 2: rect = initialRect tm.ZoomRequest(&rect) case 3: dnd3 = false } } case sdl.MouseMotionEvent: if dnd3 { dndEnd.X = gl.Int(e.X) dndEnd.Y = gl.Int(e.Y) rect = moveRectBy(rect, dndStart, dndEnd, 512, 512) tm.MoveRequest(rect) dndStart = dndEnd } else if dndDragging { dndEnd.X = gl.Int(e.X) dndEnd.Y = gl.Int(e.Y) } } } tm.Update() gl.Clear(gl.COLOR_BUFFER_BIT) tm.Draw() gl.BindTexture(gl.TEXTURE_2D, 0) if dndDragging { drawSelection(dndStart, dndEnd) } sdl.GL_SwapBuffers() } }
// For invaders or moba, does a lot of basic stuff common to both func (g *Game) renderLocalHelper(region g2.Region, local *LocalData, camera *cameraInfo, side int) { camera.doInvadersFocusRegion(g, side) gl.MatrixMode(gl.PROJECTION) gl.PushMatrix() gl.LoadIdentity() // Set the viewport so that we only render into the region that we're supposed // to render to. // TODO: Check if this works on all graphics cards - I've heard that the opengl // spec doesn't actually require that viewport does any clipping. gl.PushAttrib(gl.VIEWPORT_BIT) gl.Viewport(gl.Int(region.X), gl.Int(region.Y), gl.Sizei(region.Dx), gl.Sizei(region.Dy)) defer gl.PopAttrib() current := camera.current gl.Ortho( gl.Double(current.mid.X-current.dims.X/2), gl.Double(current.mid.X+current.dims.X/2), gl.Double(current.mid.Y+current.dims.Y/2), gl.Double(current.mid.Y-current.dims.Y/2), gl.Double(1000), gl.Double(-1000), ) defer func() { gl.MatrixMode(gl.PROJECTION) gl.PopMatrix() gl.MatrixMode(gl.MODELVIEW) }() gl.MatrixMode(gl.MODELVIEW) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) level := g.Levels[GidInvadersStart] zoom := camera.current.dims.X / float64(region.Dims.Dx) level.ManaSource.Draw(local, zoom, float64(level.Room.Dx), float64(level.Room.Dy)) gl.Color4d(1, 1, 1, 1) var expandedPoly linear.Poly for _, poly := range g.Levels[GidInvadersStart].Room.Walls { // Don't draw counter-clockwise polys, specifically this means don't draw // the boundary of the level. if poly.IsCounterClockwise() { continue } // KLUDGE: This will expand the polygon slightly so that it actually shows // up when the los shadows are drawn over it. Eventually there should be // separate los polys, colision polys, and draw polys so that this isn't // necessary. gl.Begin(gl.TRIANGLE_FAN) expandPoly(poly, &expandedPoly) for _, v := range expandedPoly { gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) } gl.End() } gui.SetFontColor(0, 255, 0, 255) for side, pos := range g.Levels[GidInvadersStart].Room.Starts { base.GetDictionary("luxisr").RenderString(fmt.Sprintf("S%d", side), pos.X, pos.Y, 0, 100, gui.Center) } gl.Color4d(1, 1, 1, 1) for _, ent := range g.temp.AllEnts { ent.Draw(g, side) } gl.Disable(gl.TEXTURE_2D) if local.mode != LocalModeMoba { panic("Need to implement drawing players from standard mode data") } for i := range local.moba.players { p := &local.moba.players[i] if p.abs.activeAbility != nil { p.abs.activeAbility.Draw(p.gid, g, side) } } for _, proc := range g.Processes { proc.Draw(Gid(""), g, side) } gl.Color4ub(0, 0, 255, 200) g.renderLosMask(local) }
func InitShaders() { render.Queue(func() { vertex_shaders = make(map[string]gl.Uint) fragment_shaders = make(map[string]gl.Uint) shader_progs = make(map[string]gl.Uint) warned_names = make(map[string]bool) RemoveRegistry("shaders") RegisterRegistry("shaders", make(map[string]*shaderDef)) RegisterAllObjectsInDir("shaders", filepath.Join(GetDataDir(), "shaders"), ".json", "json") names := GetAllNamesInRegistry("shaders") for _, name := range names { // Load the shader files shader := Shader{Defname: name} GetObject("shaders", &shader) vdata, err := ioutil.ReadFile(filepath.Join(GetDataDir(), shader.Vertex_path)) if err != nil { Error().Printf("Unable to load vertex shader '%s': %v", shader.Vertex_path, err) continue } fdata, err := ioutil.ReadFile(filepath.Join(GetDataDir(), shader.Fragment_path)) if err != nil { Error().Printf("Unable to load fragment shader '%s': %v", shader.Fragment_path, err) continue } // Create the vertex shader vertex_id, ok := vertex_shaders[shader.Vertex_path] if !ok { vertex_id = gl.CreateShader(gl.VERTEX_SHADER) pointer := &vdata[0] length := gl.Int(len(vdata)) gl.ShaderSource(vertex_id, 1, (**gl.Char)(unsafe.Pointer(&pointer)), &length) gl.CompileShader(vertex_id) var param gl.Int gl.GetShaderiv(vertex_id, gl.COMPILE_STATUS, ¶m) if param == 0 { Error().Printf("Failed to compile vertex shader '%s': %v", shader.Vertex_path, param) continue } } // Create the fragment shader fragment_id, ok := fragment_shaders[shader.Fragment_path] if !ok { fragment_id = gl.CreateShader(gl.FRAGMENT_SHADER) pointer := &fdata[0] length := gl.Int(len(fdata)) gl.ShaderSource(fragment_id, 1, (**gl.Char)(unsafe.Pointer(&pointer)), &length) gl.CompileShader(fragment_id) var param gl.Int gl.GetShaderiv(fragment_id, gl.COMPILE_STATUS, ¶m) if param == 0 { Error().Printf("Failed to compile fragment shader '%s': %v", shader.Fragment_path, param) continue } } // shader successfully compiled - now link program_id := gl.CreateProgram() gl.AttachShader(program_id, vertex_id) gl.AttachShader(program_id, fragment_id) gl.LinkProgram(program_id) var param gl.Int gl.GetProgramiv(program_id, gl.LINK_STATUS, ¶m) if param == 0 { Error().Printf("Failed to link shader '%s': %v", shader.Name, param) continue } vertex_shaders[shader.Vertex_path] = vertex_id fragment_shaders[shader.Fragment_path] = fragment_id shader_progs[shader.Name] = program_id } }) }
func (g *Game) renderLocalArchitect(region g2.Region, local *LocalData) { local.architect.camera.doArchitectFocusRegion(g, local.sys) gl.MatrixMode(gl.PROJECTION) gl.PushMatrix() gl.LoadIdentity() // Set the viewport so that we only render into the region that we're supposed // to render to. // TODO: Check if this works on all graphics cards - I've heard that the opengl // spec doesn't actually require that viewport does any clipping. gl.PushAttrib(gl.VIEWPORT_BIT) gl.Viewport(gl.Int(region.X), gl.Int(region.Y), gl.Sizei(region.Dx), gl.Sizei(region.Dy)) defer gl.PopAttrib() current := local.architect.camera.current gl.Ortho( gl.Double(current.mid.X-current.dims.X/2), gl.Double(current.mid.X+current.dims.X/2), gl.Double(current.mid.Y+current.dims.Y/2), gl.Double(current.mid.Y-current.dims.Y/2), gl.Double(1000), gl.Double(-1000), ) defer func() { gl.MatrixMode(gl.PROJECTION) gl.PopMatrix() gl.MatrixMode(gl.MODELVIEW) }() gl.MatrixMode(gl.MODELVIEW) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) zoom := local.architect.camera.current.dims.X / float64(region.Dims.Dx) level := g.Levels[GidInvadersStart] level.ManaSource.Draw(local, zoom, float64(level.Room.Dx), float64(level.Room.Dy)) gl.Begin(gl.LINES) gl.Color4d(1, 1, 1, 1) for _, poly := range g.Levels[GidInvadersStart].Room.Walls { for i := range poly { seg := poly.Seg(i) gl.Vertex2d(gl.Double(seg.P.X), gl.Double(seg.P.Y)) gl.Vertex2d(gl.Double(seg.Q.X), gl.Double(seg.Q.Y)) } } gl.End() gl.Color4ub(0, 255, 0, 255) for side, pos := range g.Levels[GidInvadersStart].Room.Starts { base.GetDictionary("luxisr").RenderString(fmt.Sprintf("S%d", side), pos.X, pos.Y, 0, 100, gui.Center) } gl.Color4d(1, 1, 1, 1) for _, ent := range g.temp.AllEnts { ent.Draw(g, -1) // TODO: Side isn't defined for architect yet } gl.Disable(gl.TEXTURE_2D) g.renderLosMask(local) if local.architect.abs.activeAbility != nil { local.architect.abs.activeAbility.Draw("", g, -1) // TODO: side not defined for architect } }