func drawInnerSlicedBox(pos, size mgl64.Vec2, borderColor, backgroundColor mgl64.Vec3) {
if size[0] == 0 || size[1] == 0 {
return
}
const OuterDistance = 2.5
gl.Begin(gl.POLYGON)
gl.Color3dv((*float64)(&borderColor[0]))
gl.Vertex2d(float64(pos[0]+OuterDistance), float64(pos[1]))
gl.Vertex2d(float64(pos[0]), float64(pos[1]+OuterDistance))
gl.Vertex2d(float64(pos[0]), float64(pos[1]-OuterDistance+size[1]))
gl.Vertex2d(float64(pos[0]+OuterDistance), float64(pos[1]+size[1]))
gl.Vertex2d(float64(pos[0]-OuterDistance+size[0]), float64(pos[1]+size[1]))
gl.Vertex2d(float64(pos[0]+size[0]), float64(pos[1]-OuterDistance+size[1]))
gl.Vertex2d(float64(pos[0]+size[0]), float64(pos[1]+OuterDistance))
gl.Vertex2d(float64(pos[0]-OuterDistance+size[0]), float64(pos[1]))
gl.End()
const InnerDistance = OuterDistance + (math.Sqrt2 - 1)
gl.Begin(gl.POLYGON)
gl.Color3dv((*float64)(&backgroundColor[0]))
gl.Vertex2d(float64(pos[0]+InnerDistance), float64(pos[1]+1))
gl.Vertex2d(float64(pos[0]+1), float64(pos[1]+InnerDistance))
gl.Vertex2d(float64(pos[0]+1), float64(pos[1]-InnerDistance+size[1]))
gl.Vertex2d(float64(pos[0]+InnerDistance), float64(pos[1]-1+size[1]))
gl.Vertex2d(float64(pos[0]-InnerDistance+size[0]), float64(pos[1]-1+size[1]))
gl.Vertex2d(float64(pos[0]-1+size[0]), float64(pos[1]-InnerDistance+size[1]))
gl.Vertex2d(float64(pos[0]-1+size[0]), float64(pos[1]+InnerDistance))
gl.Vertex2d(float64(pos[0]-InnerDistance+size[0]), float64(pos[1]+1))
gl.End()
}
func drawRoom(room *Room) {
h := float64(room.Box.GetAsBox().Height)
w := float64(room.Box.GetAsBox().Width)
x1 := float64(0 - w*0.5)
y1 := float64(0 - h*0.5)
x2 := float64(0 + w*0.5)
y2 := float64(0 - h*0.5)
x3 := float64(0 + w*0.5)
y3 := float64(0 + h*0.5)
x4 := float64(0 - w*0.5)
y4 := float64(0 + h*0.5)
gl.Begin(gl.POLYGON)
gl.Color4f(
room.Color.X(),
room.Color.Y(),
room.Color.Z(),
room.Color.W(),
)
gl.Vertex2d(x1, y1)
gl.Vertex2d(x2, y2)
gl.Vertex2d(x3, y3)
gl.Vertex2d(x4, y4)
gl.End()
gl.Begin(gl.LINE_LOOP)
gl.Color4f(.3, .3, 1, .9)
gl.LineWidth(1.0)
gl.Vertex2d(x1, y1)
gl.Vertex2d(x2, y2)
gl.Vertex2d(x3, y3)
gl.Vertex2d(x4, y4)
gl.End()
}
func drawScene(w *glfw.Window) {
width, height := w.GetFramebufferSize()
ratio := float32(width) / float32(height)
var x1, x2, y1, y2 float32
if ratio > 1 {
x1, x2, y1, y2 = -ratio, ratio, -1, 1
} else {
x1, x2, y1, y2 = -1, 1, -1/ratio, 1/ratio
}
gl.Viewport(0, 0, int32(width), int32(height))
gl.Clear(gl.COLOR_BUFFER_BIT)
// Applies subsequent matrix operations to the projection matrix stack
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity() // replace the current matrix with the identity matrix
gl.Ortho(float64(x1), float64(x2), float64(y1), float64(y2), 1, -1) // multiply the current matrix with an orthographic matrix
// Applies subsequent matrix operations to the modelview matrix stack
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.LineWidth(1)
gl.Begin(gl.LINE) // delimit the vertices of a primitive or a group of like primitives
gl.Color3f(0, 0, 0) // set the current color
gl.Vertex3f(0, y1, 0)
gl.Vertex3f(0, y2, 0)
gl.Vertex3f(x1, 0, 0)
gl.Vertex3f(x2, 0, 0)
gl.End()
gl.Rotatef(float32(glfw.GetTime()*50), 0, 0, 1) // multiply the current matrix by a rotation matrix
s := float32(.95)
gl.Begin(gl.TRIANGLES)
gl.Color3f(1, 0, 0) // set the current color
gl.Vertex3f(0, s, 0) // specify a vertex
gl.Color3f(0, 1, 0)
gl.Vertex3f(s*.866, s*-0.5, 0)
gl.Color3f(0, 0, 1)
gl.Vertex3f(s*-.866, s*-0.5, 0)
gl.End()
gl.LineWidth(5)
gl.Begin(gl.LINE_LOOP)
for i := float64(0); i < 2*math.Pi; i += .05 {
r, g, b := hsb2rgb(float32(i/(2*math.Pi)), 1, 1)
gl.Color3f(r, g, b)
gl.Vertex3f(s*float32(math.Sin(i)), s*float32(math.Cos(i)), 0)
}
gl.End()
}
func (ctx *DrawContext) drawHud(o *orrery.Orrery, frametime time.Duration) {
txt, size, err := ctx.createHudTexture(o, frametime)
if err != nil {
log.Fatalf(`can't create texture from text surface: %s`, err)
}
defer gl.DeleteTextures(1, &txt)
gl.MatrixMode(gl.PROJECTION)
gl.PushMatrix()
gl.LoadIdentity()
gl.Ortho(0.0, float64(ctx.width), float64(ctx.height), 0.0, -1.0, 1.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.BindTexture(gl.TEXTURE_2D, txt)
gl.Enable(gl.TEXTURE_2D)
defer gl.Disable(gl.TEXTURE_2D)
gl.Color3f(1, 1, 1)
gl.Begin(gl.QUADS)
gl.TexCoord2f(0, 0)
gl.Vertex2f(0.0, 0.0)
gl.TexCoord2f(1, 0)
gl.Vertex2f(float32(size[0]), 0.0)
gl.TexCoord2f(1, 1)
gl.Vertex2f(float32(size[0]), float32(size[1]))
gl.TexCoord2f(0, 1)
gl.Vertex2f(0.0, float32(size[1]))
gl.End()
gl.PopMatrix()
}
func drawSlide() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translatef(0, 0, -3.0)
gl.Begin(gl.QUADS)
//top left
gl.TexCoord2f(0, 0)
gl.Vertex3f(-1, 1, 0)
//top right
gl.TexCoord2f(1, 0)
gl.Vertex3f(1, 1, 0)
//bottom right
gl.TexCoord2f(1, 1)
gl.Vertex3f(1, -1, 0)
//bottom left
gl.TexCoord2f(0, 1)
gl.Vertex3f(-1, -1, 0)
gl.End()
}
func (img *glImage) DrawColoredAtXY(x, y int, color [4]float32) {
// TODO have the state knwon globally somewhere so this does not need to be
// called all the time
gl.Enable(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, img.id)
gl.Begin(gl.QUADS)
gl.Color4f(color[0], color[1], color[2], color[3])
gl.TexCoord2f(img.left, img.top)
gl.Vertex2i(int32(x), int32(y))
gl.Color4f(color[0], color[1], color[2], color[3])
gl.TexCoord2f(img.right, img.top)
gl.Vertex2i(int32(x+img.Width), int32(y))
gl.Color4f(color[0], color[1], color[2], color[3])
gl.TexCoord2f(img.right, img.bottom)
gl.Vertex2i(int32(x+img.Width), int32(y+img.Height))
gl.Color4f(color[0], color[1], color[2], color[3])
gl.TexCoord2f(img.left, img.bottom)
gl.Vertex2i(int32(x), int32(y+img.Height))
gl.End()
}
func piirräPisteetSiirrolla(pisteet []vec2.Vector, siirto vec2.Vector) {
gl.Begin(gl.LINE_STRIP)
for _, p := range pisteet {
piirräPiste(p.Plus(siirto))
}
gl.End()
}
// OpenGL draw function
func draw() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Enable(gl.BLEND)
gl.Enable(gl.POINT_SMOOTH)
gl.Enable(gl.LINE_SMOOTH)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.LoadIdentity()
gl.Begin(gl.LINES)
gl.Color3f(.2, .2, .2)
for i := range staticLines {
x := staticLines[i].GetAsSegment().A.X
y := staticLines[i].GetAsSegment().A.Y
gl.Vertex3f(float32(x), float32(y), 0)
x = staticLines[i].GetAsSegment().B.X
y = staticLines[i].GetAsSegment().B.Y
gl.Vertex3f(float32(x), float32(y), 0)
}
gl.End()
gl.Color4f(.3, .3, 1, .8)
// draw balls
for _, ball := range balls {
gl.PushMatrix()
pos := ball.Body.Position()
rot := ball.Body.Angle() * chipmunk.DegreeConst
gl.Translatef(float32(pos.X), float32(pos.Y), 0.0)
gl.Rotatef(float32(rot), 0, 0, 1)
drawCircle(float64(ballRadius), 60)
gl.PopMatrix()
}
}
// drawCircle draws a circle for the specified radius, rotation angle, and the specified number of sides
func drawCircle(radius float64, sides int) {
gl.Begin(gl.LINE_LOOP)
for a := 0.0; a < 2*math.Pi; a += (2 * math.Pi / float64(sides)) {
gl.Vertex2d(math.Sin(a)*radius, math.Cos(a)*radius)
}
gl.Vertex3f(0, 0, 0)
gl.End()
}
// drawCircle draws a circle for the specified radius, rotation angle, and the specified number of sides
func drawCircle(radius float64, sides int) {
gl.Begin(gl.TRIANGLE_FAN)
for a := 0.0; a < 2*math.Pi; a += (2 * math.Pi / float64(70)) {
gl.Vertex2d(math.Sin(a)*radius, math.Cos(a)*radius)
}
gl.Vertex3f(0, 0, 0)
gl.End()
}
func drawInnerRoundedBox(pos, size mgl64.Vec2, borderColor, backgroundColor mgl64.Vec3) {
if size[0] == 0 || size[1] == 0 {
return
}
const totalSlices = 4 * 16
const borderWidth = 1
const radius = 2.5 + borderWidth
var x = float64(totalSlices)
gl.Color3dv((*float64)(&backgroundColor[0]))
gl.Begin(gl.TRIANGLE_STRIP)
for i := 0; i <= totalSlices/4; i++ {
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(totalSlices-i)/x)*(radius-borderWidth), pos[1]+radius-math.Cos(Tau*float64(totalSlices-i)/x)*(radius-borderWidth))
}
for i := totalSlices / 4; i <= totalSlices/2; i++ {
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+size[1]-radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(totalSlices-i)/x)*(radius-borderWidth), pos[1]+size[1]-radius-math.Cos(Tau*float64(totalSlices-i)/x)*(radius-borderWidth))
}
gl.End()
gl.Color3dv((*float64)(&borderColor[0]))
gl.Begin(gl.TRIANGLE_STRIP)
gl.Vertex2d(pos[0]+radius, pos[1])
gl.Vertex2d(pos[0]+radius, pos[1]+borderWidth)
for i := 0; i <= totalSlices/4; i++ {
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*radius, pos[1]+radius-math.Cos(Tau*float64(i)/x)*radius)
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
}
for i := totalSlices / 4; i <= totalSlices/2; i++ {
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*radius, pos[1]+size[1]-radius-math.Cos(Tau*float64(i)/x)*radius)
gl.Vertex2d(pos[0]+size[0]-radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+size[1]-radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
}
for i := totalSlices / 2; i <= totalSlices*3/4; i++ {
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(i)/x)*radius, pos[1]+size[1]-radius-math.Cos(Tau*float64(i)/x)*radius)
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+size[1]-radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
}
for i := totalSlices * 3 / 4; i <= totalSlices; i++ {
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(i)/x)*radius, pos[1]+radius-math.Cos(Tau*float64(i)/x)*radius)
gl.Vertex2d(pos[0]+radius+math.Sin(Tau*float64(i)/x)*(radius-borderWidth), pos[1]+radius-math.Cos(Tau*float64(i)/x)*(radius-borderWidth))
}
gl.End()
}
func Piirrä() {
gl.Begin(gl.QUADS)
for i, r := range kartta {
x := i % kartanLeveys
y := i / kartanLeveys
piirräRuutu(x, y, r)
}
piirräRuutu(PelaajaX, PelaajaY, Pelaaja)
gl.End()
}
func drawSelection(x, y, p, w float32) {
gl.LineWidth(w)
gl.Begin(gl.LINE_STRIP)
gl.Vertex2f(x-p, y-p)
gl.Vertex2f(x+256+p, y-p)
gl.Vertex2f(x+256+p, y+240+p)
gl.Vertex2f(x-p, y+240+p)
gl.Vertex2f(x-p, y-p)
gl.End()
}
func (this *Pointer) Render() {
switch {
case this.VirtualCategory == POINTING && len(this.State.Axes) >= 2:
// Prevent pointer from being drawn when the OS mouse pointer is visible.
{
// HACK
var windowSize [2]int
if globalWindow != nil {
windowSize[0], windowSize[1] = globalWindow.GetSize()
}
// HACK: OS X specific.
const border = 3
if this.State.Axes[1] < 0 || this.State.Axes[0] < border || this.State.Axes[0] >= float64(windowSize[0])-border || this.State.Axes[1] >= float64(windowSize[1])-border {
break
}
}
gl.PushMatrix()
defer gl.PopMatrix()
gl.Translated(float64(NearInt64(this.State.Axes[0]))+0.5, float64(NearInt64(this.State.Axes[1]))+0.5, 0)
const size float64 = 12 * 40 / 40
gl.Color3d(1, 1, 1)
gl.Begin(gl.TRIANGLE_FAN)
gl.Vertex2d(0, 0)
gl.Vertex2d(0, size)
gl.Vertex2d(size*0.85*math.Sin(math.Pi/8), size*0.85*math.Cos(math.Pi/8))
gl.Vertex2d(size/math.Sqrt2, size/math.Sqrt2)
gl.End()
gl.Begin(gl.LINE_LOOP)
gl.Color3d(0, 0, 0)
gl.Vertex2d(0, 0)
gl.Vertex2d(0, size)
gl.Color3d(0.75, 0.75, 0.75)
gl.Vertex2d(size*0.85*math.Sin(math.Pi/8), size*0.85*math.Cos(math.Pi/8))
gl.Color3d(0, 0, 0)
gl.Vertex2d(size/math.Sqrt2, size/math.Sqrt2)
gl.End()
}
}
func draw() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Enable(gl.BLEND)
gl.Enable(gl.POINT_SMOOTH)
gl.Enable(gl.LINE_SMOOTH)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.LoadIdentity()
//Transform screen to keep player in middle. Added intentation to make obvious the push matrix is like a block
gl.PushMatrix()
// gl.Translatef((1280/2)-float32(player.x), 0, 0.0)
// gl.Begin(gl.LINES)
// gl.Color3f(.2, .5, .2)
// for i := range staticLines {
// x := staticLines[i].GetAsSegment().A.X
// y := staticLines[i].GetAsSegment().A.Y
// gl.Vertex3f(float32(x), float32(y), 0)
// x = staticLines[i].GetAsSegment().B.X
// y = staticLines[i].GetAsSegment().B.Y
// gl.Vertex3f(float32(x), float32(y), 0)
// }
// gl.End()
gl.Color4f(player.color_r, player.color_g, player.color_b, player.color_a)
//Draw Player
gl.PushMatrix()
rot := player.rot
pos_x := player.x
pos_y := player.y
gl.Translatef(pos_x, pos_y, 0.0)
gl.Rotatef(float32(rot), 0, 0, 1)
drawCircle(float64(BALL_RADIUS), 20)
gl.PopMatrix()
//Draw the grapple
gl.PushMatrix()
gl.Translatef(player.hook.x_end, player.hook.y_end, 0.0)
drawCircle(float64(5), 5)
gl.PopMatrix()
//Grapple Line
gl.LineWidth(2.5)
gl.Color3f(1.0, 0.0, 0.0)
gl.Begin(gl.LINES)
gl.Vertex3f(player.x, player.y, 0.0)
gl.Vertex3f(player.hook.x_end, player.hook.y_end, 0)
gl.End()
//Second Pop
gl.PopMatrix()
}
func (back *glbackend) Fill(b Bounds) {
gl.Color4ub(back.current.back.RGBA())
gl.Begin(gl.QUADS)
{
gl.Vertex2f(b.Min.X, b.Min.Y)
gl.Vertex2f(b.Max.X, b.Min.Y)
gl.Vertex2f(b.Max.X, b.Max.Y)
gl.Vertex2f(b.Min.X, b.Max.Y)
}
gl.End()
}
func (back *glbackend) Stroke(b Bounds) {
gl.Color4ub(back.current.fore.RGBA())
gl.Begin(gl.LINE_LOOP)
{
gl.Vertex2f(b.Min.X, b.Min.Y)
gl.Vertex2f(b.Max.X, b.Min.Y)
gl.Vertex2f(b.Max.X, b.Max.Y)
gl.Vertex2f(b.Min.X, b.Max.Y)
}
gl.End()
}
func (e *Element) Render() {
gl.Color4f(e.color.R, e.color.G, e.color.B, e.color.A)
gl.Begin(gl.QUADS)
gl.Vertex3f(e.x, e.y, 0)
gl.Vertex3f(e.x, e.y+e.height, 0)
gl.Vertex3f(e.x+e.width, e.y+e.height, 0)
gl.Vertex3f(e.x+e.width, e.y, 0)
gl.End()
}
func drawgl() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.Begin(gl.TRIANGLES)
gl.Color3f(1.0, 0.0, 0.0)
gl.Vertex2f(0.5, 0.0)
gl.Color3f(0.0, 1.0, 0.0)
gl.Vertex2f(-0.5, -0.5)
gl.Color3f(0.0, 0.0, 1.0)
gl.Vertex2f(-0.5, 0.5)
gl.End()
}
func (stash *Stash) FlushDraw() {
i := 0
texture := stash.ttTextures[i]
tt := true
for {
if texture.nverts > 0 {
gl.Enable(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, texture.id)
for k := 0; k < texture.nverts; k++ {
gl.Begin(gl.QUADS)
gl.Color4fv(&texture.color[0])
gl.TexCoord2f(texture.verts[k*4+2], texture.verts[k*4+3])
gl.Vertex2f(texture.verts[k*4+0], texture.verts[k*4+1])
k++
gl.Color4fv(&texture.color[0])
gl.TexCoord2f(texture.verts[k*4+2], texture.verts[k*4+3])
gl.Vertex2f(texture.verts[k*4+0], texture.verts[k*4+1])
k++
gl.Color4fv(&texture.color[0])
gl.TexCoord2f(texture.verts[k*4+2], texture.verts[k*4+3])
gl.Vertex2f(texture.verts[k*4+0], texture.verts[k*4+1])
k++
gl.Color4fv(&texture.color[0])
gl.TexCoord2f(texture.verts[k*4+2], texture.verts[k*4+3])
gl.Vertex2f(texture.verts[k*4+0], texture.verts[k*4+1])
gl.End()
}
gl.Disable(gl.TEXTURE_2D)
texture.nverts = 0
}
if tt {
if i < len(stash.ttTextures)-1 {
i++
texture = stash.ttTextures[i]
} else {
i = 0
if len(stash.bmTextures) > 0 {
texture = stash.bmTextures[i]
tt = false
} else {
break
}
}
} else {
if i < len(stash.bmTextures)-1 {
i++
texture = stash.bmTextures[i]
} else {
break
}
}
}
}
func glRect(x, y, w, h, r, g, b, a float32) {
gl.Disable(gl.TEXTURE_2D) // TODO do this once and remember the state
gl.Begin(gl.QUADS)
gl.Color4f(r, g, b, a)
gl.Vertex2f(x, y)
gl.Color4f(r, g, b, a)
gl.Vertex2f(x+w, y)
gl.Color4f(r, g, b, a)
gl.Vertex2f(x+w, y+h)
gl.Color4f(r, g, b, a)
gl.Vertex2f(x, y+h)
gl.End()
}
func InitFont() {
LoadTexture(filepath.FromSlash("/Users/Dmitri/Dropbox/Work/2015/Bitmap Fonts/Helvetica Neue.png"))
oFontBase = gl.GenLists(32 + 96)
for i := 0; i < 96; i++ {
const shiftY = float64(1.0 / 6)
indexX, indexY := i%16, i/16
charWidth := shiftXs[indexY][indexX+1] - shiftXs[indexY][indexX]
gl.NewList(oFontBase+uint32(i+32), gl.COMPILE)
gl.Begin(gl.QUADS)
gl.TexCoord2d(shiftXs[indexY][indexX], float64(indexY)*shiftY)
gl.Vertex2d(0, 0)
gl.TexCoord2d(shiftXs[indexY][indexX+1], float64(indexY)*shiftY)
gl.Vertex2d(fontWidth*charWidth/float64(1.0/16), 0)
gl.TexCoord2d(shiftXs[indexY][indexX+1], float64(indexY+1)*shiftY)
gl.Vertex2d(fontWidth*charWidth/float64(1.0/16), fontHeight)
gl.TexCoord2d(shiftXs[indexY][indexX], float64(indexY+1)*shiftY)
gl.Vertex2d(0, fontHeight)
gl.End()
gl.Translated(fontWidth*charWidth/float64(1.0/16), 0.0, 0.0)
gl.EndList()
}
oFontBackground = gl.GenLists(1)
gl.NewList(oFontBackground, gl.COMPILE)
gl.Begin(gl.QUADS)
gl.Vertex2d(0, 0)
gl.Vertex2d(0, fontHeight)
gl.Vertex2d(fontWidth, fontHeight)
gl.Vertex2d(fontWidth, 0)
gl.End()
gl.Translated(fontWidth, 0.0, 0.0)
gl.EndList()
CheckGLError()
}
func (ctx *DrawContext) drawGrid() {
gl.Disable(gl.DEPTH_TEST)
defer gl.Enable(gl.DEPTH_TEST)
for i := float32(-500); i <= 500; i += 5 {
gl.Begin(gl.LINES)
gl.Color3f(0.2, 0.2, 0.2)
gl.Vertex3f(-500, i, 0)
gl.Vertex3f(500, i, 0)
gl.Vertex3f(i, -500, 0)
gl.Vertex3f(i, 500, 0)
gl.End()
}
}
func (m *menu) draw() {
return // TODO
gl.Disable(gl.TEXTURE_2D)
gl.Begin(gl.QUADS)
gl.Color4f(m.color.r, m.color.g, m.color.b, m.color.a)
gl.Vertex2f(m.pos.x, m.pos.y)
gl.Color4f(m.color.r, m.color.g, m.color.b, m.color.a)
gl.Vertex2f(m.pos.x+m.pos.w, m.pos.y)
gl.Color4f(m.color.r, m.color.g, m.color.b, m.color.a)
gl.Vertex2f(m.pos.x+m.pos.w, m.pos.y+m.pos.h)
gl.Color4f(m.color.r, m.color.g, m.color.b, m.color.a)
gl.Vertex2f(m.pos.x, m.pos.y+m.pos.h)
gl.End()
}
func InitFont() {
LoadTexture(filepath.Join("data", "Font.png"))
oFontBase = gl.GenLists(32 + 96*4)
for i := 0; i < 96*4; i++ {
const shiftX, shiftY = float64(1.0 / 16), float64(1.0 / 6 / 4)
indexX, indexY := i%16, i/16
gl.NewList(oFontBase+uint32(i+32), gl.COMPILE)
gl.Begin(gl.QUADS)
gl.TexCoord2d(float64(indexX)*shiftX, float64(indexY)*shiftY)
gl.Vertex2i(0, 0)
gl.TexCoord2d(float64(indexX+1)*shiftX, float64(indexY)*shiftY)
gl.Vertex2i(fontWidth, 0)
gl.TexCoord2d(float64(indexX+1)*shiftX, float64(indexY+1)*shiftY)
gl.Vertex2i(fontWidth, fontHeight)
gl.TexCoord2d(float64(indexX)*shiftX, float64(indexY+1)*shiftY)
gl.Vertex2i(0, fontHeight)
gl.End()
gl.Translated(fontWidth, 0.0, 0.0)
gl.EndList()
}
oFontBackground = gl.GenLists(1)
gl.NewList(oFontBackground, gl.COMPILE)
gl.Begin(gl.QUADS)
gl.Vertex2i(0, 0)
gl.Vertex2i(0, fontHeight)
gl.Vertex2i(fontWidth, fontHeight)
gl.Vertex2i(fontWidth, 0)
gl.End()
gl.Translated(fontWidth, 0.0, 0.0)
gl.EndList()
CheckGLError()
}
// OpenGL draw function
func draw() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Enable(gl.BLEND)
gl.Enable(gl.POINT_SMOOTH)
gl.Enable(gl.LINE_SMOOTH)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.LoadIdentity()
player := game.Player
//Transform screen.
gl.PushMatrix()
gl.Translatef((1280/2)-float32((player.Body.Position().X)), 0, 0.0)
gl.Begin(gl.LINES)
gl.Color3f(.2, .5, .2)
for _, segment := range game.Level.GetChipmunkSegments() {
x := segment.GetAsSegment().A.X
y := segment.GetAsSegment().A.Y
gl.Vertex3f(float32(x), float32(y), 0)
x = segment.GetAsSegment().B.X
y = segment.GetAsSegment().B.Y
gl.Vertex3f(float32(x), float32(y), 0)
}
gl.End()
gl.Color4f(.9, .1, 1, .9)
// draw balls
for _, enemy := range game.Enemies {
gl.PushMatrix()
pos := enemy.Body.Position()
rot := enemy.Body.Angle() * game.DegreeConst
gl.Translatef(float32(pos.X), float32(pos.Y), 0.0)
gl.Rotatef(float32(rot), 0, 0, 1)
drawCircle(float64(enemy.Radius), 60)
gl.PopMatrix()
}
gl.Color4f(.3, .3, 1, .8)
//Draw Player
gl.PushMatrix()
pos := player.Body.Position()
rot := player.Body.Angle() * game.DegreeConst
gl.Translatef(float32(pos.X), float32(pos.Y), 0.0)
gl.Rotatef(float32(rot), 0, 0, 1)
drawCircle(float64(player.Radius), 60)
gl.PopMatrix()
gl.PopMatrix()
}
func piirrä(aika float64) {
gl.Begin(gl.LINES)
gl.Color3d(1, 1, 1)
gl.Vertex2d(0, 0)
gl.Color3d(0, 0, 0)
gl.Vertex2d(0.5, 0)
gl.Color3d(1, 0, 0)
gl.Vertex2d(0, 0)
gl.Vertex2d(0, 0.5)
gl.End()
}
func drawThumbnail(x, y, tx, ty, tw, th float32) {
sx := x + 4
sy := y + 4
gl.Disable(gl.TEXTURE_2D)
gl.Color3f(0.2, 0.2, 0.2)
gl.Begin(gl.QUADS)
gl.Vertex2f(sx, sy)
gl.Vertex2f(sx+256, sy)
gl.Vertex2f(sx+256, sy+240)
gl.Vertex2f(sx, sy+240)
gl.End()
gl.Enable(gl.TEXTURE_2D)
gl.Color3f(1, 1, 1)
gl.Begin(gl.QUADS)
gl.TexCoord2f(tx, ty)
gl.Vertex2f(x, y)
gl.TexCoord2f(tx+tw, ty)
gl.Vertex2f(x+256, y)
gl.TexCoord2f(tx+tw, ty+th)
gl.Vertex2f(x+256, y+240)
gl.TexCoord2f(tx, ty+th)
gl.Vertex2f(x, y+240)
gl.End()
}
func (atlas *FontAtlas) Draw(text string, b Bounds) {
atlas.LoadGlyphs(text)
gl.Enable(gl.BLEND)
defer gl.Disable(gl.BLEND)
gl.BlendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.TEXTURE_2D)
defer gl.Disable(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, atlas.Texture)
x := b.Min.X + atlas.drawPadding
y := (b.Max.Y+b.Min.Y)/2 + (ceilPxf(atlas.maxBounds.Min.Y)+ceilPxf(atlas.maxBounds.Max.Y))/2
p := rune(0)
for _, r := range text {
glyph := atlas.Rendered[r]
dx := float32(glyph.Loc.Dx())
dy := float32(glyph.Loc.Dy())
px := x + ceilPxf(glyph.Bounds.Min.X) - glyphPadding
py := y + ceilPxf(glyph.Bounds.Min.Y) - glyphPadding
// this is not the ideal way of positioning the letters
// will create positioning artifacts
// but it the result is more
px = float32(math.Trunc(float64(px)))
py = float32(math.Trunc(float64(py)))
gl.Begin(gl.QUADS)
{
gl.TexCoord2f(glyph.RelLoc.Min.X, glyph.RelLoc.Min.Y)
gl.Vertex2f(px, py)
gl.TexCoord2f(glyph.RelLoc.Max.X, glyph.RelLoc.Min.Y)
gl.Vertex2f(px+dx, py)
gl.TexCoord2f(glyph.RelLoc.Max.X, glyph.RelLoc.Max.Y)
gl.Vertex2f(px+dx, py+dy)
gl.TexCoord2f(glyph.RelLoc.Min.X, glyph.RelLoc.Max.Y)
gl.Vertex2f(px, py+dy)
}
gl.End()
k := atlas.Face.Kern(p, r)
p = r
x += ceilPxf(glyph.Advance + k)
}
}
func (o openGLCanvas) FillRect(what color.Color, where image.Rectangle) {
return //this does not work at all... makes the whole image red
drawX := float32(where.Min.X) * o.scaleX
drawY := float32(where.Min.Y) * o.scaleY
endX := float32(where.Max.X) * o.scaleX
endY := float32(where.Max.Y) * o.scaleY
r, g, b, a := what.RGBA()
gl.Color4f(float32(r)/0xFF, float32(g)/0xFF, float32(b)/0xFF, float32(a)/0xFF)
gl.Begin(gl.QUADS)
{
gl.Vertex3f(drawX, drawY, 0)
gl.Vertex3f(drawX, endX, 0)
gl.Vertex3f(endX, endY, 0)
gl.Vertex3f(endX, drawY, 0)
}
gl.End()
}
