func (w *Window) run() {
runtime.LockOSThread()
glfw.MakeContextCurrent(w.w)
defer glfw.MakeContextCurrent(nil)
// glfw should fire initial resize events to avoid this duplication (https://github.com/glfw/glfw/issues/62)
width, height := w.w.Size()
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(width), 0, gl.Double(height), -1, 1)
Resize(w, Pt(float64(width), float64(height)))
width, height = w.w.FramebufferSize()
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
gl.Enable(gl.BLEND)
gl.Enable(gl.POINT_SMOOTH)
gl.Enable(gl.LINE_SMOOTH)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
for !w.close {
select {
case f := <-w.do:
f()
case <-w.paint:
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
w.base().paint()
w.w.SwapBuffers()
}
}
}
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 (g *Gui) Draw() {
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(g.region.X), gl.Double(g.region.X+g.region.Dx), gl.Double(g.region.Y+g.region.Dy), gl.Double(g.region.Y), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
g.root.Draw(g.region, &styleStack{})
}
func (r Region) setClipPlanes() {
eqs[0][0], eqs[0][1], eqs[0][2], eqs[0][3] = 1, 0, 0, -gl.Double(r.X)
eqs[1][0], eqs[1][1], eqs[1][2], eqs[1][3] = -1, 0, 0, gl.Double(r.X+r.Dx)
eqs[2][0], eqs[2][1], eqs[2][2], eqs[2][3] = 0, 1, 0, -gl.Double(r.Y)
eqs[3][0], eqs[3][1], eqs[3][2], eqs[3][3] = 0, -1, 0, gl.Double(r.Y+r.Dy)
gl.ClipPlane(gl.CLIP_PLANE0, &eqs[0][0])
gl.ClipPlane(gl.CLIP_PLANE1, &eqs[1][0])
gl.ClipPlane(gl.CLIP_PLANE2, &eqs[2][0])
gl.ClipPlane(gl.CLIP_PLANE3, &eqs[3][0])
}
func (w *Window) resized(width, height int) {
wid, hei := float64(width), float64(height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(wid), 0, gl.Double(hei), -1, 1)
w.Self.Resize(wid, hei)
if w.centralView != nil {
w.centralView.Resize(wid, hei)
}
}
func (vb *VertexBuffer) InitVertexData(
points []Point3,
colors []Color,
texCoords [][2]float64) {
vb.VertexData = make([]gl.Double, len(points)*3)
for i := range points {
vb.VertexData[3*i+0] = gl.Double(points[i].X)
vb.VertexData[3*i+1] = gl.Double(points[i].Y)
vb.VertexData[3*i+2] = gl.Double(points[i].Z)
}
vb.ColorData = make([]gl.Double, len(colors)*4)
for i := range colors {
vb.ColorData[4*i+0] = gl.Double(colors[i].R)
vb.ColorData[4*i+1] = gl.Double(colors[i].G)
vb.ColorData[4*i+2] = gl.Double(colors[i].B)
vb.ColorData[4*i+3] = gl.Double(colors[i].A)
}
vb.TexCoordData = make([]gl.Double, len(texCoords)*2)
for i := range texCoords {
vb.TexCoordData[2*i+0] = gl.Double(texCoords[i][0])
vb.TexCoordData[2*i+1] = gl.Double(texCoords[i][1])
}
}
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 (o *OpenGl) set2dView() {
gl.Disable(gl.TEXTURE_2D)
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.LIGHTING)
gl.Disable(gl.LIGHT0)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(o.width), 0, gl.Double(o.height), -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
}
func (editor *editorData) renderPlaceBlock(g *Game) {
var expandedPoly linear.Poly
expandPoly(editor.getPoly(g), &expandedPoly)
gl.Disable(gl.TEXTURE_2D)
gl.Color4d(1, 1, 1, 1)
gl.Begin(gl.TRIANGLE_FAN)
for _, v := range expandedPoly {
gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y))
}
gl.End()
}
func (v *ViewBase) paint() {
if v.hidden {
return
}
gl.PushMatrix()
defer gl.PopMatrix()
d := MapToParent(ZP, v)
gl.Translated(gl.Double(d.X), gl.Double(d.Y), 0)
v.Self.Paint()
for _, child := range v.children {
child.base().paint()
}
}
func (g *Gui) Draw() {
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
region := g.root.Render_region
gl.Ortho(gl.Double(region.X), gl.Double(region.X+region.Dx), gl.Double(region.Y), gl.Double(region.Y+region.Dy), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
g.root.Draw(region)
if g.FocusWidget() != nil {
g.FocusWidget().DrawFocused(region)
}
}
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 initScene(width, height int, init func()) (err error) {
gl.Disable(gl.DEPTH_TEST)
gl.ClearColor(0.5, 0.5, 0.5, 0.0)
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(width), gl.Double(height), 0, 0, 1)
gl.MatrixMode(gl.MODELVIEW)
init()
return
}
func (a *app) OnResize(w, h int) {
oaspect := float64(a.imgW()) / float64(a.imgH())
haspect := float64(w) / float64(h)
vaspect := float64(h) / float64(w)
var scx, scy float64
if oaspect > haspect {
scx = 1
scy = haspect / oaspect
} else {
scx = vaspect * oaspect
scy = 1
}
gl.Viewport(0, 0, gl.Sizei(w), gl.Sizei(h))
gl.LoadIdentity()
gl.Scaled(gl.Double(scx), gl.Double(scy), 1)
}
func drawScene() {
fps()
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
if input.Zoom > 0 {
gl.Ortho(0, gl.Double(float64(*flagSize)/input.Zoom), gl.Double(float64(*flagSize)/input.Zoom), 0, -1, 1.0)
}
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translatef(gl.Float(input.TransX*1), gl.Float(input.TransY*1), 0)
drawGrid()
drawCells()
}
func InitViewport() {
gl.Viewport(0, 0, gl.Sizei(Width), gl.Sizei(Height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
x := gl.Double(float64(Height) / float64(Width))
gl.Frustum(-1./2., 1./2., -x/2, x/2, 10, 100)
}
func getPlayers(console *base.Console) []gin.DeviceId {
var ct controllerTracker
gin.In().RegisterEventListener(&ct)
defer gin.In().UnregisterEventListener(&ct)
ticker := time.Tick(time.Millisecond * 17)
start := time.Time{}
readyDuration := time.Second * 2
for start.IsZero() || time.Now().Sub(start) < readyDuration {
<-ticker
sys.Think()
if ct.Ready() && start.IsZero() {
start = time.Now()
}
if !ct.Ready() {
start = time.Time{}
}
render.Queue(func() {
defer console.Draw(0, 0, wdx, wdy)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Disable(gl.DEPTH_TEST)
gui.SetFontColor(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(0), gl.Double(wdx), gl.Double(wdy), gl.Double(0), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Num players: %d", len(ct.ids)), float64(wdx)/2, 300, 0, 100, gui.Center)
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Num ready: %d", ct.NumReady()), float64(wdx)/2, 400, 0, 100, gui.Center)
if !start.IsZero() {
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Starting in %2.2f", (readyDuration-time.Now().Sub(start)).Seconds()), float64(wdx)/2, 500, 0, 100, gui.Center)
}
})
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
}
var devices []gin.DeviceId
for id := range ct.ids {
devices = append(devices, id)
}
return devices
}
func mainLoop(client sgf.ClientEngine, controllers []gin.DeviceId, console *base.Console) {
client.MakeRequest(game.Join{Rebels: make([]*game.RebelPlayer, 2)})
ticker := time.Tick(time.Millisecond * 17)
render.Queue(func() {
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
})
for {
<-ticker
if gin.In().GetKey(gin.AnyEscape).FramePressCount() != 0 {
return
}
sys.Think()
render.Queue(func() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Disable(gl.DEPTH_TEST)
gui.SetFontColor(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(0), gl.Double(wdx), gl.Double(wdy), gl.Double(0), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
base.GetDictionary("crackin").RenderString("Waiting on some nubs", float64(wdx)/2, 300, 0, 100, gui.Center)
})
client.RLock()
g := client.Game().(*game.Game)
mode := g.Mode
client.RUnlock()
if mode == game.ModeWaiting {
} else if mode == game.ModeProgram {
programLoop(client, controllers, console)
} else if mode == game.ModeRun {
}
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
}
}
func (m *Matrix4) toGL() Matrix4GL {
var glm Matrix4GL
for i := range m {
glm[i] = gl.Double(m[i])
}
return glm
}
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 (t *Text) Paint() {
SetColor(t.backgroundColor)
FillRect(InnerRect(t).Inset(t.frameSize))
if t.frameSize > 0 {
SetColor(t.frameColor)
SetLineWidth(t.frameSize)
DrawRect(InnerRect(t))
}
if t.cursor {
SetColor(t.textColor)
SetLineWidth(2)
x := t.frameSize + t.font.Advance(t.text)
DrawLine(Pt(x, t.frameSize), Pt(x, Height(t)-2*t.frameSize))
}
SetColor(t.textColor)
gl.Translated(gl.Double(t.frameSize), gl.Double(t.frameSize-t.font.Descender()), 0)
t.font.Render(t.text)
}
func glInit(width, height int) {
gl.Init()
gl.Enable(gl.TEXTURE_2D)
gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(width), gl.Double(height), 0, -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.EnableClientState(gl.COLOR_ARRAY)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
gl.VertexPointer(2, gl.FLOAT, 0, gl.Pointer(&vs[0]))
gl.ColorPointer(3, gl.UNSIGNED_BYTE, 0, gl.Pointer(&cs[0]))
gl.TexCoordPointer(2, gl.FLOAT, 0, gl.Pointer(&ts[0]))
}
func (g *Game) renderWalls() {
gl.Color4d(1, 1, 1, 1)
var expandedPoly linear.Poly
for _, poly := range g.Level.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()
}
}
func (p *pullProcess) Draw(player_id int, g *game.Game) {
gl.Color4d(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
player := g.GetEnt(player_id).(*game.Player)
v1 := player.Pos()
v2 := v1.Add(linear.Vec2{1000, 0})
v3 := v2.RotateAround(v1, player.Angle-p.Angle/2)
v4 := v2.RotateAround(v1, player.Angle+p.Angle/2)
gl.Begin(gl.LINES)
vs := []linear.Vec2{v3, v4, linear.Vec2{player.X, player.Y}}
for i := range vs {
gl.Vertex2d(gl.Double(vs[i].X), gl.Double(vs[i].Y))
gl.Vertex2d(gl.Double(vs[(i+1)%len(vs)].X), gl.Double(vs[(i+1)%len(vs)].Y))
}
gl.End()
s := fmt.Sprintf("%.2f", p.supplied)
base.Log().Printf("'%s'", s)
if true {
base.GetDictionary("luxisr").RenderString(s, 10, 10, 0, 50, gin.Left)
}
}
func (p *pullProcess) 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
}
gl.Color4d(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
v1 := player.Pos()
v2 := v1.Add(linear.Vec2{1000, 0})
v3 := v2.RotateAround(v1, player.Angle-p.Angle/2)
v4 := v2.RotateAround(v1, player.Angle+p.Angle/2)
gl.Begin(gl.LINES)
vs := []linear.Vec2{v3, v4, player.Pos()}
for i := range vs {
gl.Vertex2d(gl.Double(vs[i].X), gl.Double(vs[i].Y))
gl.Vertex2d(gl.Double(vs[(i+1)%len(vs)].X), gl.Double(vs[(i+1)%len(vs)].Y))
}
gl.End()
}
func perspective(fov, aspect, zNear, zFar gl.Double) {
var xmin, xmax, ymin, ymax gl.Double
ymax = zNear * gl.Double(math.Tan(float64(fov*math.Pi/360.0)))
ymin = -ymax
xmin = ymin * aspect
xmax = ymax * aspect
xmin += -1.0 / zNear
xmax += -1.0 / zNear
gl.Frustum(xmin, xmax, ymin, ymax, zNear, zFar)
}
func (p *pull) Draw(ent game.Ent, g *game.Game) {
if !p.draw {
return
}
player, ok := ent.(*game.PlayerEnt)
if !ok {
return
}
// TODO: Don't draw for enemies?
gl.Color4d(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
v1 := player.Pos()
v2 := v1.Add(linear.Vec2{1000, 0})
v3 := v2.RotateAround(v1, player.Angle()-p.angle/2)
v4 := v2.RotateAround(v1, player.Angle()+p.angle/2)
gl.Begin(gl.LINES)
vs := []linear.Vec2{v3, v4, player.Pos()}
for i := range vs {
gl.Vertex2d(gl.Double(vs[i].X), gl.Double(vs[i].Y))
gl.Vertex2d(gl.Double(vs[(i+1)%len(vs)].X), gl.Double(vs[(i+1)%len(vs)].Y))
}
gl.End()
}
func (tm *ThunderMenu) Draw(region Region, style StyleStack) {
// Set clip planes
gl.PushAttrib(gl.TRANSFORM_BIT)
defer gl.PopAttrib()
var eqs [4][4]gl.Double
eqs[0][0], eqs[0][1], eqs[0][2], eqs[0][3] = 1, 0, 0, -gl.Double(region.X)
eqs[1][0], eqs[1][1], eqs[1][2], eqs[1][3] = -1, 0, 0, gl.Double(region.X+region.Dx)
eqs[2][0], eqs[2][1], eqs[2][2], eqs[2][3] = 0, 1, 0, -gl.Double(region.Y)
eqs[3][0], eqs[3][1], eqs[3][2], eqs[3][3] = 0, -1, 0, gl.Double(region.Y+region.Dy)
gl.Enable(gl.CLIP_PLANE0)
gl.Enable(gl.CLIP_PLANE1)
gl.Enable(gl.CLIP_PLANE2)
gl.Enable(gl.CLIP_PLANE3)
gl.ClipPlane(gl.CLIP_PLANE0, &eqs[0][0])
gl.ClipPlane(gl.CLIP_PLANE1, &eqs[1][0])
gl.ClipPlane(gl.CLIP_PLANE2, &eqs[2][0])
gl.ClipPlane(gl.CLIP_PLANE3, &eqs[3][0])
var start, end int
if tm.delta <= 0 {
start = tm.current + int(math.Floor(tm.delta))
end = tm.current
region.X += int(float64(region.Dx) * (float64(start-tm.current) - tm.delta))
} else {
start = tm.current
end = tm.current + int(math.Ceil(tm.delta))
region.X += int(float64(region.Dx) * (float64(end-tm.current) - tm.delta - math.Floor(tm.delta) - 1))
}
var offset linear.Vec2
offset.X = (float64(tm.current) + tm.delta) * float64(region.Dx)
for i := start; i <= end; i++ {
style.PushStyle(map[string]interface{}{"offset": offset})
tm.Subs[tm.menuStack[i]].Draw(region, style)
style.Pop()
region.X += region.Dx
}
}
func (gw *GameWindow) Draw(region gui.Region) {
gw.region = region
latest_region = region
gl.PushMatrix()
defer gl.PopMatrix()
gl.Translated(gl.Double(gw.region.X), gl.Double(gw.region.Y), 0)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gw.game.manaSource.Draw(gw, float64(gw.game.Dx), float64(gw.game.Dy))
gl.Begin(gl.LINES)
gl.Color4d(1, 1, 1, 1)
for _, poly := range gw.game.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.Begin(gl.TRIANGLE_FAN)
gl.Color4d(1, 0, 0, 1)
for _, poly := range gw.game.Room.Lava {
for _, v := range poly {
gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y))
}
}
gl.End()
gl.Color4d(1, 1, 1, 1)
for _, ent := range gw.game.Ents {
ent.Draw(gw.game)
}
gl.Disable(gl.TEXTURE_2D)
for _, player := range local.players {
if player.active_ability != nil {
player.active_ability.Draw(player.id, gw.game)
}
}
// base.GetDictionary("luxisr").RenderString("monkeys!!!", 10, 10, 0, float64(gw.game.Game_thinks), gin.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()
}