func (cpap *controlPointAttackProcess) Draw(id Gid, g *Game, side int) { base.EnableShader("circle") base.SetUniformF("circle", "edge", 0.9) // For people on the controlling side this will draw a circle around the area // that is being targeted by the control point. if cpap.Side == side && cpap.Timer >= cpap.LockTime { gl.Color4ub(200, 200, 200, 80) texture.Render( cpap.LockPos.X-50, cpap.LockPos.Y-50, 2*50, 2*50) } // This draws the projectile itself. if cpap.Timer >= cpap.FireTime { gl.Color4ub(255, 50, 50, 240) texture.Render( cpap.ProjPos.X-5, cpap.ProjPos.Y-5, 2*5, 2*5) } base.EnableShader("") }
// TODO: This function really needs to take not just the side, but the player // that this is being drawn for. func (p *placeMineCastProcess) Draw(gid game.Gid, g *game.Game, side int) { player, _ := g.Ents[p.PlayerGid].(*game.PlayerEnt) if player == nil { return } if side != player.Side() { return } ready := int(p.Stored[game.ColorBlue] / p.Cost) base.EnableShader("status_bar") if ready == 0 { gl.Color4ub(255, 0, 0, 255) } else { gl.Color4ub(0, 255, 0, 255) } var outer float32 = 0.2 var increase float32 = 0.01 frac := p.Stored[game.ColorBlue] / p.Cost base.SetUniformF("status_bar", "frac", float32(frac-float64(ready))) base.SetUniformF("status_bar", "inner", outer-increase*float32(ready+1)) base.SetUniformF("status_bar", "outer", outer) base.SetUniformF("status_bar", "buffer", 0.01) texture.Render(player.Pos().X-100, player.Pos().Y-100, 200, 200) if ready > 0 { base.SetUniformF("status_bar", "frac", 1.0) base.SetUniformF("status_bar", "inner", outer-float32(ready)*increase) base.SetUniformF("status_bar", "outer", outer) texture.Render(player.Pos().X-100, player.Pos().Y-100, 200, 200) } base.EnableShader("") }
func (p *multiDrain) Draw(src, obs game.Gid, game *game.Game) { if src != obs { return } ent := game.Ents[src] if ent == nil { return } base.EnableShader("status_bar") frac := p.Stored ready := math.Floor(frac) if ready == 0 { gl.Color4ub(255, 0, 0, 255) } else { gl.Color4ub(0, 255, 0, 255) } outer := 0.2 increase := 0.01 base.SetUniformF("status_bar", "frac", float32(frac-ready)) base.SetUniformF("status_bar", "inner", float32(outer-increase*(ready+1))) base.SetUniformF("status_bar", "outer", float32(outer)) base.SetUniformF("status_bar", "buffer", 0.01) texture.Render(ent.Pos().X-100, ent.Pos().Y-100, 200, 200) if ready > 0 { base.SetUniformF("status_bar", "frac", 1.0) base.SetUniformF("status_bar", "inner", float32(outer-ready*increase)) base.SetUniformF("status_bar", "outer", float32(outer)) texture.Render(ent.Pos().X-100, ent.Pos().Y-100, 200, 200) } base.EnableShader("") }
func setColorForIndex(index int) { switch index { case 0: gl.Color4ub(255, 0, 0, 200) case 1: gl.Color4ub(0, 255, 0, 200) case 2: gl.Color4ub(0, 0, 255, 200) default: gl.Color4ub(255, 0, 255, 200) } }
func (fe fireExplosion) Draw(test bool) { base.EnableShader("circle") base.SetUniformF("circle", "edge", 0.7) if test { gl.Color4ub(200, 200, 200, gl.Ubyte(150*fe.Alpha())) } else { gl.Color4ub(255, 50, 10, gl.Ubyte(150*fe.Alpha())) } texture.Render( fe.Pos.X-fe.Size(), fe.Pos.Y-fe.Size(), 2*fe.Size(), 2*fe.Size()) base.EnableShader("") }
func (p *PlayerEnt) Draw(game *Game) { var t *texture.Data var alpha gl.Ubyte if game.local.Side == p.Side() { alpha = gl.Ubyte(255.0 * (1.0 - p.Stats().Cloaking()/2)) } else { alpha = gl.Ubyte(255.0 * (1.0 - p.Stats().Cloaking())) } gl.Color4ub(255, 255, 255, alpha) // if p.Id() == 1 { t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship.png")) // } else if p.Id() == 2 { // t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship3.png")) // } else { // t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship2.png")) // } t.RenderAdvanced( p.Position.X-float64(t.Dx())/2, p.Position.Y-float64(t.Dy())/2, float64(t.Dx()), float64(t.Dy()), p.Angle_, false) for _, proc := range p.Processes { proc.Draw(p.Id(), game.local.Gid, game) } base.EnableShader("status_bar") base.SetUniformF("status_bar", "inner", 0.08) base.SetUniformF("status_bar", "outer", 0.09) base.SetUniformF("status_bar", "buffer", 0.01) base.SetUniformF("status_bar", "frac", 1.0) gl.Color4ub(125, 125, 125, alpha/2) texture.Render(p.Position.X-100, p.Position.Y-100, 200, 200) health_frac := float32(p.Stats().HealthCur() / p.Stats().HealthMax()) if health_frac > 0.5 { color_frac := 1.0 - (health_frac-0.5)*2.0 gl.Color4ub(gl.Ubyte(255.0*color_frac), 255, 0, alpha) } else { color_frac := health_frac * 2.0 gl.Color4ub(255, gl.Ubyte(255.0*color_frac), 0, alpha) } base.SetUniformF("status_bar", "frac", health_frac) texture.Render(p.Position.X-100, p.Position.Y-100, 200, 200) base.EnableShader("") }
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 (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 (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 drawScene() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Rotated(-90, 1, 0, 0) //gl.Rotated(90, 0, 0, 1) gl.Rotated(gl.Double(-viewAngles[2]), 1, 0, 0) gl.Rotated(gl.Double(-viewAngles[0]), 0, 1, 0) gl.Rotated(gl.Double(-viewAngles[1]), 0, 0, 1) gl.Translated(gl.Double(viewOrg[0]), gl.Double(viewOrg[1]), gl.Double(viewOrg[2])) var r, g, b gl.Ubyte for i, face := range model.Faces { r = gl.Ubyte(i) + 100 g = gl.Ubyte(i>>1) + 100 b = gl.Ubyte(i>>2) + 100 if model.Triangle { gl.Begin(gl.TRIANGLES) } else { gl.Begin(gl.LINES) } gl.Color4ub(r, g, b, 0xff) for _, v := range face.Verts { gl.Vertex3d(gl.Double(v.Pos[0]), gl.Double(v.Pos[1]), gl.Double(v.Pos[2])) } gl.End() } }
func (wp *waypoint) RenderOnFloor() { if !wp.active { return } wp.drawn = true gl.Color4ub(200, 0, 0, 128) base.EnableShader("waypoint") base.SetUniformF("waypoint", "radius", float32(wp.Radius)) t := float32(time.Now().UnixNano()%1e15) / 1.0e9 base.SetUniformF("waypoint", "time", t) gl.Begin(gl.QUADS) gl.TexCoord2i(0, 1) gl.Vertex2i(int32(wp.X-wp.Radius), int32(wp.Y-wp.Radius)) gl.TexCoord2i(0, 0) gl.Vertex2i(int32(wp.X-wp.Radius), int32(wp.Y+wp.Radius)) gl.TexCoord2i(1, 0) gl.Vertex2i(int32(wp.X+wp.Radius), int32(wp.Y+wp.Radius)) gl.TexCoord2i(1, 1) gl.Vertex2i(int32(wp.X+wp.Radius), int32(wp.Y-wp.Radius)) gl.End() base.EnableShader("") // base.EnableShader("") }
func (ob *OptionBasic) DrawInfo(x, y, dx, dy int) { gl.Color4ub(255, 255, 255, 255) tx := x + (dx-ob.Large.Data().Dx())/2 ty := y + dy - ob.Large.Data().Dy() ob.Large.Data().RenderNatural(tx, ty) d := base.GetDictionary(ob.Size) d.RenderParagraph(ob.Text, float64(x), float64(y+dy-ob.Large.Data().Dy())-d.MaxHeight(), 0, float64(dx), d.MaxHeight(), gui.Left, gui.Top) }
func (cp *ControlPoint) Draw(g *Game, side int) { base.EnableShader("circle") base.SetUniformF("circle", "edge", 0.95) gl.Color4ub(50, 50, 100, 150) texture.Render( cp.Position.X-cp.Stats().Size()*2, cp.Position.Y-cp.Stats().Size()*2, 2*cp.Stats().Size()*2, 2*cp.Stats().Size()*2) base.EnableShader("status_bar") base.SetUniformF("status_bar", "inner", 0.0) base.SetUniformF("status_bar", "outer", 0.5) base.SetUniformF("status_bar", "buffer", 0.01) base.SetUniformF("status_bar", "frac", 1.0) gl.Color4ub(50, 50, 50, 200) texture.Render( cp.Position.X-cp.Stats().Size(), cp.Position.Y-cp.Stats().Size(), 2*cp.Stats().Size(), 2*cp.Stats().Size()) base.SetUniformF("status_bar", "frac", float32(cp.Control)) if cp.Controlled { if side == cp.Controller { gl.Color4ub(0, 255, 0, 255) } else { gl.Color4ub(255, 0, 0, 255) } } else { gl.Color4ub(100, 100, 100, 255) } // The texture is flipped if this is being drawn for the controlling side. // This makes it look a little nicer when someone neutralizes a control point // because it makes the angle of the pie slice thingy continue going in the // same direction as it passes the neutralization point. texture.RenderAdvanced( cp.Position.X-cp.Stats().Size(), cp.Position.Y-cp.Stats().Size(), 2*cp.Stats().Size(), 2*cp.Stats().Size(), 0, side == cp.Controller) base.EnableShader("") }
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 (p *riftWalkProcess) Draw(gid game.Gid, g *game.Game, side int) { player, ok := g.Ents[p.PlayerGid].(*game.PlayerEnt) if !ok { return } if side != player.Side() { return } frac := p.Stored.Magnitude() / p.Threshold if frac < 1 { gl.Color4ub(255, 0, 0, 255) } else { gl.Color4ub(0, 255, 0, 255) } base.EnableShader("status_bar") var outer float32 = 0.2 var increase float32 = 0.01 if frac > 1 { frac = 1 } base.SetUniformF("status_bar", "frac", float32(frac)) base.SetUniformF("status_bar", "inner", outer-increase) base.SetUniformF("status_bar", "outer", outer) base.SetUniformF("status_bar", "buffer", 0.01) texture.Render(player.Pos().X-100, player.Pos().Y-100, 200, 200) base.EnableShader("") dist, radius := p.GetVals() dest := player.Pos().Add((linear.Vec2{dist, 0}).Rotate(player.Angle)) gl.Disable(gl.TEXTURE_2D) gl.Color4d(1, 1, 1, 1) gl.Begin(gl.LINES) gl.Vertex2d(gl.Double(player.Pos().X), gl.Double(player.Pos().Y)) gl.Vertex2d(gl.Double(dest.X), gl.Double(dest.Y)) gl.End() n := 20 gl.Begin(gl.LINES) for i := 0; i < n; i++ { v1 := dest.Add((linear.Vec2{radius, 0}).Rotate(float64(i) / float64(n) * 2 * math.Pi)) v2 := dest.Add((linear.Vec2{radius, 0}).Rotate(float64(i+1) / float64(n) * 2 * math.Pi)) gl.Vertex2d(gl.Double(v1.X), gl.Double(v1.Y)) gl.Vertex2d(gl.Double(v2.X), gl.Double(v2.Y)) } gl.End() }
func (co *colorOption) DrawInfo(x, y, dx, dy int) { gl.Disable(gl.TEXTURE_2D) gl.Color4ub(co.r, co.g, co.b, co.a) gl.Begin(gl.QUADS) gl.Vertex2i(int32(x), int32(y)) gl.Vertex2i(int32(x), int32(y+dy)) gl.Vertex2i(int32(x+dx), int32(y+dy)) gl.Vertex2i(int32(x+dx), int32(y)) gl.End() }
func (c *CreepEnt) Draw(g *Game) { base.EnableShader("status_bar") base.SetUniformF("status_bar", "inner", 0.01) base.SetUniformF("status_bar", "outer", 0.03) base.SetUniformF("status_bar", "buffer", 0.01) base.SetUniformF("status_bar", "frac", 1.0) if c.Side() == g.local.Side { gl.Color4ub(100, 255, 100, 255) } else { gl.Color4ub(255, 100, 100, 255) } texture.Render(c.Position.X-100, c.Position.Y-100, 200, 200) base.SetUniformF("status_bar", "inner", 0.04) base.SetUniformF("status_bar", "outer", 0.045) base.SetUniformF("status_bar", "buffer", 0.01) base.SetUniformF("status_bar", "frac", 1.0) texture.Render(c.Position.X-100, c.Position.Y-100, 200, 200) base.EnableShader("") }
func (g *Game) renderEdges() { // Draw edges between nodes for _, ent := range g.Ents { cp0, ok := ent.(*ControlPoint) if !ok { continue } for _, target := range cp0.Targets { cp1, ok := g.Ents[target].(*ControlPoint) if !ok { continue } ally := 0 enemy := 0 if cp0.Side() == g.local.Side { ally++ } else if cp0.Side() == -1 { enemy++ } if cp1.Side() == g.local.Side { ally++ } else if cp1.Side() == -1 { enemy++ } if ally == 2 { gl.Color4ub(0, 255, 0, 255) } else if enemy == 2 { gl.Color4ub(255, 0, 0, 255) } else if ally == 1 { gl.Color4ub(255, 255, 0, 255) } else if enemy == 1 { gl.Color4ub(255, 0, 0, 255) } else { gl.Color4ub(200, 200, 200, 255) } gl.Begin(gl.LINES) gl.Vertex2d(gl.Double(cp0.Pos().X), gl.Double(cp0.Pos().Y)) gl.Vertex2d(gl.Double(cp1.Pos().X), gl.Double(cp1.Pos().Y)) gl.End() } } }
func (p *asplosionProc) Draw(src, obs game.Gid, game *game.Game) { base.EnableShader("circle") base.SetUniformF("circle", "edge", 0.7) gl.Color4ub(255, 50, 10, gl.Ubyte(150)) texture.Render( p.Pos.X-p.CurrentRadius, p.Pos.Y-p.CurrentRadius, 2*p.CurrentRadius, 2*p.CurrentRadius) base.EnableShader("") }
func (ep *EntityPlacer) Draw(region gui.Region) { ep.region = region gl.Color4ub(255, 255, 255, 255) ep.layout.Texture.Data().RenderNatural(region.X, region.Y) for _, button := range ep.buttons { button.RenderAt(ep.region.X, ep.region.Y) } d := base.GetDictionary(ep.layout.Roster.Points.Size) x_off := ep.layout.Roster.Points.X_off y_off := ep.layout.Roster.Points.Y_off for i, button := range ep.ent_buttons { cost := ep.roster[ep.roster_names[i]] x := float64(button.X + x_off) y := float64(button.Y + y_off) d.RenderString(fmt.Sprintf("%d", cost), x, y, 0, d.MaxHeight(), gui.Right) } gl.Color4ub(255, 255, 255, 255) var ent *Entity if !pointInsideRect(ep.mx, ep.my, region.X, region.Y, region.Dx, region.Dy) { ent = ep.game.new_ent } if ep.hovered != nil { ent = ep.hovered } if ent != nil { ent.Still.Data().RenderNatural(ep.layout.Face.X, ep.layout.Face.Y) ep.layout.Name.RenderString(ent.Name) ep.layout.Ap.RenderString(fmt.Sprintf("Ap:%d", ent.Stats.ApCur())) ep.layout.Hp.RenderString(fmt.Sprintf("Hp:%d", ent.Stats.HpCur())) ep.layout.Corpus.RenderString(fmt.Sprintf("Corpus:%d", ent.Stats.Corpus())) ep.layout.Ego.RenderString(fmt.Sprintf("Ego:%d", ent.Stats.Ego())) } if ep.show_points { d := base.GetDictionary(ep.layout.Points_remaining.Size) x := float64(ep.layout.Points_remaining.X) y := float64(ep.layout.Points_remaining.Y) d.RenderString(ep.layout.Points_remaining.String, x, y, 0, d.MaxHeight(), gui.Left) w := d.StringWidth(ep.layout.Points_remaining.String) d.RenderString(fmt.Sprintf("%d", ep.points), x+w, y, 0, d.MaxHeight(), gui.Right) } }
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 (mo *MapOption) Draw(hovered, selected, selectable bool, region gui.Region) { var s byte switch { case selected: s = 255 case hovered && selectable: s = 205 case selectable: s = 127 default: s = 75 } gl.Color4ub(s, s, s, 255) icon := mo.house_def.Icon.Data() if icon.Dx() == 0 { icon = mo.layout.Default_icon.Data() } icon.RenderNatural(region.X, region.Y) gl.Color4ub(0, 0, 0, 255) d := base.GetDictionary(15) d.RenderString(mo.house_def.Name, float64(region.X), float64(region.Y), 0, d.MaxHeight(), gui.Left) }
func (p *lightningBoltProc) Draw(src, obs game.Gid, game *game.Game) { if p.NumThinks < p.BuildThinks { return } base.EnableShader("lightning") base.SetUniformV2("lightning", "dir", p.Seg.Ray().Norm()) base.SetUniformV2("lightning", "bolt_root", p.Seg.P.Add(p.Seg.Q).Scale(0.5)) base.SetUniformF("lightning", "bolt_thickness", 1.1) gl.Disable(gl.TEXTURE_2D) displayWidth := p.Width * 10 perp := p.Seg.Ray().Cross().Norm().Scale(displayWidth / 2) move := float32(p.NumThinks) / float32(60) / 10.0 for i := 0; i < 3; i++ { base.SetUniformF("lightning", "rand_offset", float32(i)+move) if i == 2 { base.SetUniformF("lightning", "bolt_thickness", 1.3) } switch i { case 0: gl.Color4ub(255, 200, 200, 200) case 1: gl.Color4ub(255, 255, 200, 200) case 2: gl.Color4ub(255, 255, 230, 225) } gl.Begin(gl.QUADS) v := p.Seg.P.Add(perp) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) v = p.Seg.Q.Add(perp) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) v = p.Seg.Q.Sub(perp) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) v = p.Seg.P.Sub(perp) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) gl.End() } base.EnableShader("") }
func (p *burstProcess) Draw(player_id int, g *game.Game) { player := g.GetEnt(player_id).(*game.Player) base.EnableShader("circle") prog := p.Remaining_initial.Magnitude() / p.Initial.Magnitude() base.SetUniformF("circle", "progress", 1-float32(prog)) gl.Color4ub(255, 255, 255, 255) radius := 40.0 texture.Render( player.X-radius, player.Y-radius, 2*radius, 2*radius) base.EnableShader("") }
func (f *Furniture) Render(pos mathgl.Vec2, width float32) { var rgba [4]float64 gl.GetDoublev(gl.CURRENT_COLOR, &rgba[0]) gl.PushAttrib(gl.CURRENT_BIT) if !f.Blocks_los || !f.alpha_enabled { f.alpha = 1 } gl.Color4ub(byte(255*rgba[0]), byte(255*rgba[1]), byte(255*rgba[2]), byte(255*rgba[3]*f.alpha)) orientation := f.Orientations[f.Rotation] dy := width * float32(orientation.Texture.Data().Dy()) / float32(orientation.Texture.Data().Dx()) // orientation.Texture.Data().Render(float64(pos.X), float64(pos.Y), float64(width), float64(dy)) orientation.Texture.Data().RenderAdvanced(float64(pos.X), float64(pos.Y), float64(width), float64(dy), 0, !f.Flip) gl.PopAttrib() }
func (f *lightning) Draw(ent game.Ent, g *game.Game) { if !f.draw { return } gl.Disable(gl.TEXTURE_2D) gl.Color4ub(255, 255, 255, 255) forward := (linear.Vec2{1, 0}).Rotate(ent.Angle()).Scale(100000.0) gl.Begin(gl.LINES) v := ent.Pos().Add(forward) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) v = ent.Pos().Sub(forward) gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y)) gl.End() }
func (e *Entity) drawReticle(pos mathgl.Vec2, rgba [4]float64) { if !e.hovered && !e.selected && !e.controlled { return } gl.PushAttrib(gl.CURRENT_BIT) r := byte(rgba[0] * 255) g := byte(rgba[1] * 255) b := byte(rgba[2] * 255) a := byte(rgba[3] * 255) switch { case e.controlled: gl.Color4ub(0, 0, r, a) case e.selected: gl.Color4ub(r, g, b, a) default: gl.Color4ub(r, g, b, byte((int(a)*200)>>8)) } glow := texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ui", "glow.png")) dx := float64(e.last_render_width + 0.5) dy := float64(e.last_render_width * 150 / 100) glow.Render(float64(pos.X), float64(pos.Y), dx, dy) gl.PopAttrib() }
func (m *HeatSeeker) Draw(g *Game, side int) { base.EnableShader("status_bar") base.SetUniformF("status_bar", "inner", 0.01) base.SetUniformF("status_bar", "outer", 0.03) base.SetUniformF("status_bar", "buffer", 0.01) base.SetUniformF("status_bar", "frac", 1.0) gl.Color4ub(255, 255, 255, 255) texture.Render(m.Position.X-100, m.Position.Y-100, 200, 200) base.SetUniformF("status_bar", "inner", 0.04) base.SetUniformF("status_bar", "outer", 0.045) base.SetUniformF("status_bar", "buffer", 0.01) health_frac := float32(m.Stats().HealthCur() / m.Stats().HealthMax()) if health_frac > 0.5 { color_frac := 1.0 - (health_frac-0.5)*2.0 gl.Color4ub(gl.Ubyte(255.0*color_frac), 255, 0, 255) } else { color_frac := health_frac * 2.0 gl.Color4ub(255, gl.Ubyte(255.0*color_frac), 0, 255) } base.SetUniformF("status_bar", "frac", health_frac) texture.Render(m.Position.X-100, m.Position.Y-100, 200, 200) base.EnableShader("") }
func renderBoard(g *game.Game, x, y, dx, dy int) { tx := dx / len(g.Level.Tiles) ty := dy / len(g.Level.Tiles[0]) gl.Enable(gl.TEXTURE_2D) gl.Color4ub(255, 255, 255, 255) for i := range g.Level.Tiles { for j := range g.Level.Tiles[i] { if g.Level.Tiles[i][j].Type == game.TileEmpty { tilePath := filepath.Join(base.GetDataDir(), fmt.Sprintf("textures/tile%d.png", (i+j)%4+1)) tile := texture.LoadFromPath(tilePath) tile.Render(float64(x+i*tx), float64(y+j*ty), float64(tx), float64(ty)) } } } }
func (o *Overlay) Draw(region gui.Region) { o.region = region switch o.game.Side { case SideHaunt: if o.game.los.denizens.mode == LosModeBlind { return } case SideExplorers: if o.game.los.intruders.mode == LosModeBlind { return } default: return } for _, wp := range o.game.Waypoints { if !wp.active || wp.drawn { continue } cx := float32(wp.X) cy := float32(wp.Y) r := float32(wp.Radius) cx1, cy1 := o.game.viewer.BoardToWindow(cx-r, cy-r) cx2, cy2 := o.game.viewer.BoardToWindow(cx-r, cy+r) cx3, cy3 := o.game.viewer.BoardToWindow(cx+r, cy+r) cx4, cy4 := o.game.viewer.BoardToWindow(cx+r, cy-r) gl.Color4ub(200, 0, 0, 128) base.EnableShader("waypoint") base.SetUniformF("waypoint", "radius", float32(wp.Radius)) t := float32(time.Now().UnixNano()%1e15) / 1.0e9 base.SetUniformF("waypoint", "time", t) gl.Begin(gl.QUADS) gl.TexCoord2i(0, 1) gl.Vertex2i(int32(cx1), int32(cy1)) gl.TexCoord2i(0, 0) gl.Vertex2i(int32(cx2), int32(cy2)) gl.TexCoord2i(1, 0) gl.Vertex2i(int32(cx3), int32(cy3)) gl.TexCoord2i(1, 1) gl.Vertex2i(int32(cx4), int32(cy4)) gl.End() base.EnableShader("") } }