func (w *Window) run(init func(w *Window)) {
runtime.LockOSThread()
glfw.MakeContextCurrent(w.w)
defer glfw.MakeContextCurrent(nil)
init(w)
// glfw should fire initial resize events to avoid this duplication (https://github.com/glfw/glfw/issues/62)
w.resized(w.w.Size())
w.framebufferResized(w.w.FramebufferSize())
gl.Enable(gl.SCISSOR_TEST)
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.Scissor(0, 0, w.bufWidth, w.bufHeight)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
w.base().paint()
w.w.SwapBuffers()
}
}
}
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 (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 Text(x, y, z float32, str string) {
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.BLEND)
gl.RasterPos3f(x, y, z)
for _, ch := range str {
//glut.BitmapCharacter(glut.BITMAP_9_BY_15, string(ch))
}
gl.Disable(gl.BLEND)
}
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)
}
}
func Number(x, y, z, n float32) {
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.BLEND)
s := ""
fmt.Fprintf(s, "%f", n)
gl.RasterPos3f(x, y, z)
for _, ch := range s {
//glut.BitmapCharacter(glut.BITMAP_9_BY_15, string(ch))
}
gl.Disable(gl.BLEND)
}
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 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 (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 initWindow(sys system.System, width int, height int) {
sys.CreateWindow(10, 10, width, height)
sys.EnableVSync(false)
err := gl.Init()
if err != nil {
panic(err)
}
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.Enable(gl.CULL_FACE)
gl.FrontFace(gl.CW)
gl.ClearColor(0, 0, 0, 1)
}
func initScene() {
gl.Disable(gl.TEXTURE_2D)
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Disable(gl.ALPHA_TEST)
gl.Enable(gl.LINE_SMOOTH)
gl.Hint(gl.LINE_SMOOTH_HINT, gl.NICEST)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
gl.LineWidth(1.0)
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.ClearDepth(1)
//gl.DepthFunc(gl.LEQUAL)
gl.Viewport(0, 0, Width, Height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
perspective(110.0, 1.0, 4, 8192)
}
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 (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 (sb *spriteBox) Draw(region gui.Region) {
gl.Disable(gl.TEXTURE_2D)
gl.Color4d(sb.r, sb.g, sb.b, 1)
gl.Begin(gl.QUADS)
gl.Vertex2i(int32(region.X+region.Dx/3), int32(region.Y))
gl.Vertex2i(int32(region.X+region.Dx/3), int32(region.Y+region.Dy))
gl.Vertex2i(int32(region.X+region.Dx/3*2), int32(region.Y+region.Dy))
gl.Vertex2i(int32(region.X+region.Dx/3*2), int32(region.Y))
gl.End()
if sb.s != nil {
gl.Enable(gl.TEXTURE_2D)
tx, ty, tx2, ty2 := sb.s.Bind()
// fmt.Printf("Tex: %f %f %f %f\n", tx, ty, tx2, ty2)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Color4f(1, 1, 1, 1)
gl.Begin(gl.QUADS)
x := int32(region.X + region.Dx/2)
y := int32(region.Y + region.Dy/2)
gl.TexCoord2d(tx, -ty)
gl.Vertex2i(x-50, y-75)
gl.TexCoord2d(tx, -ty2)
gl.Vertex2i(x-50, y+75)
gl.TexCoord2d(tx2, -ty2)
gl.Vertex2i(x+50, y+75)
gl.TexCoord2d(tx2, -ty)
gl.Vertex2i(x+50, y-75)
gl.End()
gl.Color4d(1, 1, 1, 1)
text := fmt.Sprintf("%d : %s : %s", sb.s.Facing(), sb.s.Anim(), sb.s.AnimState())
if sb.top {
dict.RenderString(text, float64(region.X), float64(region.Y+region.Dy)-dict.MaxHeight(), 0, dict.MaxHeight(), gui.Left)
} else {
dict.RenderString(text, float64(region.X), float64(region.Y), 0, dict.MaxHeight(), gui.Left)
}
}
}
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)
}
}
// Need floor, right wall, and left wall matrices to draw the details
func (room *Room) render(floor, left, right mathgl.Mat4, zoom float32, base_alpha byte, drawables []Drawable, los_tex *LosTexture, floor_drawers []FloorDrawer) {
do_color := func(r, g, b, a byte) {
R, G, B, A := room.Color()
A = alphaMult(A, base_alpha)
gl.Color4ub(alphaMult(R, r), alphaMult(G, g), alphaMult(B, b), alphaMult(A, a))
}
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.STENCIL_TEST)
gl.ClearStencil(0)
gl.Clear(gl.STENCIL_BUFFER_BIT)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
defer gl.DisableClientState(gl.VERTEX_ARRAY)
defer gl.DisableClientState(gl.TEXTURE_COORD_ARRAY)
var vert roomVertex
planes := []plane{
{room.left_buffer, room.Wall, &left},
{room.right_buffer, room.Wall, &right},
{room.floor_buffer, room.Floor, &floor},
}
gl.PushMatrix()
defer gl.PopMatrix()
if los_tex != nil {
gl.LoadMatrixf(&floor[0])
gl.ClientActiveTexture(gl.TEXTURE1)
gl.ActiveTexture(gl.TEXTURE1)
gl.Enable(gl.TEXTURE_2D)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
los_tex.Bind()
gl.BindBuffer(gl.ARRAY_BUFFER, room.vbuffer)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
gl.ClientActiveTexture(gl.TEXTURE0)
gl.ActiveTexture(gl.TEXTURE0)
base.EnableShader("los")
base.SetUniformI("los", "tex2", 1)
}
var mul, run mathgl.Mat4
for _, plane := range planes {
gl.LoadMatrixf(&floor[0])
run.Assign(&floor)
// Render the doors and cut out the stencil buffer so we leave them empty
// if they're open
switch plane.mat {
case &left:
gl.StencilFunc(gl.ALWAYS, 1, 1)
gl.StencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE)
for _, door := range room.Doors {
if door.Facing != FarLeft {
continue
}
door.TextureData().Bind()
R, G, B, A := door.Color()
do_color(R, G, B, alphaMult(A, room.far_left.wall_alpha))
gl.ClientActiveTexture(gl.TEXTURE0)
door.TextureData().Bind()
if door.door_glids.floor_buffer != 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, door.threshold_glids.vbuffer)
gl.VertexPointer(3, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.x)))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, door.door_glids.floor_buffer)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.u)))
gl.ClientActiveTexture(gl.TEXTURE1)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
gl.DrawElements(gl.TRIANGLES, door.door_glids.floor_count, gl.UNSIGNED_SHORT, nil)
}
}
gl.StencilFunc(gl.NOTEQUAL, 1, 1)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
do_color(255, 255, 255, room.far_left.wall_alpha)
case &right:
gl.StencilFunc(gl.ALWAYS, 1, 1)
gl.StencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE)
for _, door := range room.Doors {
if door.Facing != FarRight {
continue
}
door.TextureData().Bind()
R, G, B, A := door.Color()
do_color(R, G, B, alphaMult(A, room.far_right.wall_alpha))
gl.ClientActiveTexture(gl.TEXTURE0)
door.TextureData().Bind()
if door.door_glids.floor_buffer != 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, door.threshold_glids.vbuffer)
gl.VertexPointer(3, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.x)))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, door.door_glids.floor_buffer)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.u)))
gl.ClientActiveTexture(gl.TEXTURE1)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
gl.DrawElements(gl.TRIANGLES, door.door_glids.floor_count, gl.UNSIGNED_SHORT, nil)
}
}
gl.StencilFunc(gl.NOTEQUAL, 1, 1)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
do_color(255, 255, 255, room.far_right.wall_alpha)
case &floor:
gl.StencilFunc(gl.ALWAYS, 2, 2)
gl.StencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE)
do_color(255, 255, 255, 255)
}
gl.ClientActiveTexture(gl.TEXTURE0)
gl.BindBuffer(gl.ARRAY_BUFFER, room.vbuffer)
gl.VertexPointer(3, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.x)))
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.u)))
gl.ClientActiveTexture(gl.TEXTURE1)
if los_tex != nil {
los_tex.Bind()
}
gl.BindBuffer(gl.ARRAY_BUFFER, room.vbuffer)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
// Now draw the walls
gl.LoadMatrixf(&floor[0])
plane.texture.Data().Bind()
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, plane.index_buffer)
if (plane.mat == &left || plane.mat == &right) && strings.Contains(string(room.Wall.Path), "gradient.png") {
base.EnableShader("gorey")
base.SetUniformI("gorey", "tex", 0)
base.SetUniformI("gorey", "foo", Foo)
base.SetUniformF("gorey", "num_rows", Num_rows)
base.SetUniformF("gorey", "noise_rate", Noise_rate)
base.SetUniformF("gorey", "num_steps", Num_steps)
}
if plane.mat == &floor && strings.Contains(string(room.Floor.Path), "gradient.png") {
base.EnableShader("gorey")
base.SetUniformI("gorey", "tex", 0)
base.SetUniformI("gorey", "foo", Foo)
base.SetUniformF("gorey", "num_rows", Num_rows)
base.SetUniformF("gorey", "noise_rate", Noise_rate)
base.SetUniformF("gorey", "num_steps", Num_steps)
zexp := math.Log(float64(zoom))
frac := 1 - 1/zexp
frac = (frac - 0.6) * 5.0
switch {
case frac > 0.7:
base.SetUniformI("gorey", "range", 1)
case frac > 0.3:
base.SetUniformI("gorey", "range", 2)
default:
base.SetUniformI("gorey", "range", 3)
}
}
if plane.mat == &floor {
R, G, B, _ := room.Color()
gl.Color4ub(R, G, B, 255)
}
gl.DrawElements(gl.TRIANGLES, gl.Sizei(room.floor_count), gl.UNSIGNED_SHORT, nil)
if los_tex != nil {
base.EnableShader("los")
} else {
base.EnableShader("")
}
}
for _, wt := range room.WallTextures {
if room.wall_texture_gl_map == nil {
room.wall_texture_gl_map = make(map[*WallTexture]wallTextureGlIds)
room.wall_texture_state_map = make(map[*WallTexture]wallTextureState)
}
ids := room.wall_texture_gl_map[wt]
state := room.wall_texture_state_map[wt]
var new_state wallTextureState
new_state.flip = wt.Flip
new_state.rot = wt.Rot
new_state.x = wt.X
new_state.y = wt.Y
new_state.room.x = room.X
new_state.room.y = room.Y
new_state.room.dx = room.Size.Dx
new_state.room.dy = room.Size.Dy
if new_state != state {
wt.setupGlStuff(room.X, room.Y, room.Size.Dx, room.Size.Dy, &ids)
room.wall_texture_gl_map[wt] = ids
room.wall_texture_state_map[wt] = new_state
}
gl.LoadMatrixf(&floor[0])
if ids.vbuffer != 0 {
wt.Texture.Data().Bind()
R, G, B, A := wt.Color()
gl.ClientActiveTexture(gl.TEXTURE0)
gl.BindBuffer(gl.ARRAY_BUFFER, ids.vbuffer)
gl.VertexPointer(3, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.x)))
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.u)))
gl.ClientActiveTexture(gl.TEXTURE1)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
gl.ClientActiveTexture(gl.TEXTURE0)
if ids.floor_buffer != 0 {
gl.StencilFunc(gl.ALWAYS, 2, 2)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ids.floor_buffer)
gl.Color4ub(R, G, B, A)
gl.DrawElements(gl.TRIANGLES, ids.floor_count, gl.UNSIGNED_SHORT, nil)
}
if ids.left_buffer != 0 {
gl.StencilFunc(gl.ALWAYS, 1, 1)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ids.left_buffer)
do_color(R, G, B, alphaMult(A, room.far_left.wall_alpha))
gl.DrawElements(gl.TRIANGLES, ids.left_count, gl.UNSIGNED_SHORT, nil)
}
if ids.right_buffer != 0 {
gl.StencilFunc(gl.ALWAYS, 1, 1)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ids.right_buffer)
do_color(R, G, B, alphaMult(A, room.far_right.wall_alpha))
gl.DrawElements(gl.TRIANGLES, ids.right_count, gl.UNSIGNED_SHORT, nil)
}
}
}
base.EnableShader("marble")
base.SetUniformI("marble", "tex2", 1)
base.SetUniformF("marble", "room_x", float32(room.X))
base.SetUniformF("marble", "room_y", float32(room.Y))
for _, door := range room.Doors {
door.setupGlStuff(room)
if door.threshold_glids.vbuffer == 0 {
continue
}
if door.AlwaysOpen() {
continue
}
if door.highlight_threshold {
gl.Color4ub(255, 255, 255, 255)
} else {
gl.Color4ub(128, 128, 128, 255)
}
gl.BindBuffer(gl.ARRAY_BUFFER, door.threshold_glids.vbuffer)
gl.VertexPointer(3, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.x)))
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.u)))
gl.ClientActiveTexture(gl.TEXTURE1)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(unsafe.Sizeof(vert)), gl.Pointer(unsafe.Offsetof(vert.los_u)))
gl.ClientActiveTexture(gl.TEXTURE0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, door.threshold_glids.floor_buffer)
gl.DrawElements(gl.TRIANGLES, door.threshold_glids.floor_count, gl.UNSIGNED_SHORT, nil)
}
base.EnableShader("")
if los_tex != nil {
base.EnableShader("")
gl.ActiveTexture(gl.TEXTURE1)
gl.Disable(gl.TEXTURE_2D)
gl.ActiveTexture(gl.TEXTURE0)
gl.ClientActiveTexture(gl.TEXTURE1)
gl.DisableClientState(gl.TEXTURE_COORD_ARRAY)
gl.ClientActiveTexture(gl.TEXTURE0)
}
run.Assign(&floor)
mul.Translation(float32(-room.X), float32(-room.Y), 0)
run.Multiply(&mul)
gl.LoadMatrixf(&run[0])
gl.StencilFunc(gl.EQUAL, 2, 3)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
room_rect := image.Rect(room.X, room.Y, room.X+room.Size.Dx, room.Y+room.Size.Dy)
for _, fd := range floor_drawers {
x, y := fd.Pos()
dx, dy := fd.Dims()
if room_rect.Overlaps(image.Rect(x, y, x+dx, y+dy)) {
fd.RenderOnFloor()
}
}
do_color(255, 255, 255, 255)
gl.LoadIdentity()
gl.Disable(gl.STENCIL_TEST)
room.renderFurniture(floor, 255, drawables, los_tex)
gl.ClientActiveTexture(gl.TEXTURE1)
gl.Disable(gl.TEXTURE_2D)
gl.ClientActiveTexture(gl.TEXTURE0)
base.EnableShader("")
}
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
}
}
// 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 main() {
{
f, err := os.Create("/Users/jwills/code/src/github.com/runningwild/shadertest/log.err")
if err != nil {
panic("shoot")
}
os.Stderr = f
f, err = os.Create("/Users/jwills/code/src/github.com/runningwild/shadertest/log.out")
if err != nil {
panic("shoot")
}
os.Stdout = f
}
sys.Startup()
err := gl.Init()
if err != nil {
panic(err)
}
fmt.Printf("RAWR!!!\n")
render.Init()
render.Queue(func() {
sys.CreateWindow(10, 10, wdx, wdy)
sys.EnableVSync(true)
err := gl.Init()
if err != nil {
panic(err)
}
})
base.InitShaders()
runtime.GOMAXPROCS(2)
ui, err = gui.Make(gin.In(), gui.Dims{wdx, wdy}, filepath.Join(datadir, "fonts", "skia.ttf"))
if err != nil {
panic(err)
}
anchor := gui.MakeAnchorBox(gui.Dims{wdx, wdy})
ui.AddChild(anchor)
var v float64
// var profile_output *os.File
// var num_mem_profiles int
// ui.AddChild(base.MakeConsole())
size := 19.0
base.InitShaders()
x := gl.Double(0.0)
// y := 0.0
// tex := texture.LoadFromPath(filepath.Join(base.GetDataDir(), "test/out.dff.small.png"))
fmt.Printf("RAWR!\n")
listener := Listener{}
gin.In().RegisterEventListener(&listener)
button := gin.In().GetKeyFlat(gin.ControllerButton0+6, gin.DeviceTypeController, gin.DeviceIndexAny)
fmt.Printf("RAWR!\n")
for button.FramePressCount() == 0 {
sys.Think()
// dsize := gin.In().GetKey(gin.MouseWheelVertical).FramePressAmt()
// size += dsize
// x -= float64(tex.Dx()) * dsize / 2
// y -= float64(tex.Dy()) * dsize / 2
// if gin.In().GetKey(gin.Down).FramePressAmt() > 0 {
// y += 10
// }
// if gin.In().GetKey(gin.Up).FramePressAmt() > 0 {
// y -= 10
// }
// if gin.In().GetKey(gin.Left).FramePressAmt() > 0 {
// x += 10
// }
// if gin.In().GetKey(gin.Right).FramePressAmt() > 0 {
// x -= 10
// }
render.Queue(func() {
ui.Draw()
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Disable(gl.TEXTURE_2D)
gl.Color4ub(255, 0, 0, 255)
gl.Begin(gl.QUADS)
gl.Vertex2d(100+x, 20)
gl.Vertex2d(100+x, gl.Double(size+20))
gl.Vertex2d(200+x, gl.Double(size+20))
gl.Vertex2d(200+x, 20)
x += 1
gl.End()
gl.Enable(gl.TEXTURE_2D)
gl.Color4ub(255, 255, 255, 255)
// // str := "!@#$%^&*"
// diff := 5.0 / (math.Log(size) + math.Pow(size, 0.7))
// // Works for 1200
// diff = 50 * math.Pow(base.GetDictionary("skia").Scale(), 2) / math.Pow(size, 1.0)
// // Works for 3000
// diff = 50 * math.Pow(base.GetDictionary("skia").Scale(), 1.5) / math.Pow(size, 0.8)
// //0.340637
// //0.159241
// diff = 75 * math.Pow(base.GetDictionary("skia").Scale(), 1.0) / math.Pow(size, 1.0)
// diff = 10 / math.Pow(size, 1.0)
// diff = 20/math.Pow(size, 1.0) + 5*math.Pow(base.GetDictionary("skia").Scale(), 1.0)/math.Pow(size, 1.0)
// if diff > 0.45 {
// diff = 0.45
// }
// base.EnableShader("distance_field")
// base.SetUniformF("distance_field", "dist_min", float32(0.5-diff))
// base.SetUniformF("distance_field", "dist_max", float32(0.5+diff))
// base.GetDictionary("skia").RenderString(str, 100, 20, 0, dy, gui.Left)
// base.GetDictionary("skia").RenderString(str, 100, 20+2*dy, 0, dy/4, gui.Left)
// base.GetDictionary("skia").RenderString(str, 100, 20, 0, size, gui.Left)
lorem := "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum"
kk := gin.In().GetKeyFlat(gin.ControllerAxis0Positive+1, gin.DeviceTypeController, device_index)
kl := gin.In().GetKeyFlat(gin.ControllerAxis0Positive+1, gin.DeviceTypeController, gin.DeviceIndexAny)
s := fmt.Sprintf("%1.2f %1.2f - %1.2f %1.2f", kk.FramePressAvg(), kk.FramePressAmt(), kl.FramePressAvg(), kl.FramePressAmt())
devices := sys.GetActiveDevices()
y := 500.0
for _, t := range []gin.DeviceType{gin.DeviceTypeController, gin.DeviceTypeKeyboard, gin.DeviceTypeMouse} {
for _, d := range devices[t] {
var s string
switch t {
case gin.DeviceTypeController:
s = "controller"
case gin.DeviceTypeKeyboard:
s = "keyboard"
case gin.DeviceTypeMouse:
s = "mouse"
}
base.GetDictionary("skia").RenderString(fmt.Sprintf("%s: %d", s, d), 100, y, 0, 45, gui.Left)
y -= 50
}
}
base.GetDictionary("luxisr").RenderString(s, 50, 50, 0, size, gui.Left)
// base.GetDictionary("luxisr").RenderString(lorem, 50, 50+size, 0, size, gui.Left)
base.GetDictionary("skia").RenderString(lorem, 50, 50+2*size, 0, size, gui.Left)
base.Log().Printf("Foo")
// base.EnableShader("")
// gl.Enable(gl.ALPHA_TEST)
// gl.AlphaFunc(gl.GREATER, 0.5)
// tex := texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship.png"))
// tex.Bind()
// tex.RenderAdvanced(x, y, float64(tex.Dx())*size, float64(tex.Dy())*size, 0, true)
// tex.RenderNatural(300, 100)
// gl.Disable(gl.ALPHA_TEST)
})
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
// if key_map["cpu profile"].FramePressCount() > 0 {
// if profile_output == nil {
// profile_output, err = os.Create(filepath.Join(datadir, "cpu.prof"))
// if err == nil {
// err = pprof.StartCPUProfile(profile_output)
// if err != nil {
// fmt.Printf("Unable to start CPU profile: %v\n", err)
// profile_output.Close()
// profile_output = nil
// }
// fmt.Printf("profout: %v\n", profile_output)
// } else {
// fmt.Printf("Unable to start CPU profile: %v\n", err)
// }
// } else {
// pprof.StopCPUProfile()
// profile_output.Close()
// profile_output = nil
// }
// }
// if key_map["mem profile"].FramePressCount() > 0 {
// f, err := os.Create(filepath.Join(datadir, fmt.Sprintf("mem.%d.prof", num_mem_profiles)))
// if err != nil {
// base.Error().Printf("Unable to write mem profile: %v", err)
// }
// pprof.WriteHeapProfile(f)
// f.Close()
// num_mem_profiles++
// }
v += 0.01
}
}
func (d *Dictionary) RenderString(s string, x, y, z, height float64, just Justification) {
if len(s) == 0 {
return
}
strbuf, ok := d.strs[s]
if !ok {
defer d.RenderString(s, x, y, z, height, just)
} else {
render.EnableShader("glop.font")
diff := 20/math.Pow(height, 1.0) + 5*math.Pow(d.data.Scale, 1.0)/math.Pow(height, 1.0)
if diff > 0.4 {
// TODO: Need to come up with decent values here
diff = 0.4
}
render.SetUniformF("glop.font", "dist_min", float32(0.5-diff))
render.SetUniformF("glop.font", "dist_max", float32(0.5+diff))
defer render.EnableShader("")
}
size := unsafe.Sizeof(dictVert{})
scale := height / float64(d.data.Maxy-d.data.Miny)
width := float32(d.figureWidth(s) * scale)
x_pos := float32(x)
switch just {
case Center:
x_pos -= width / 2
case Right:
x_pos -= width
}
if ok {
gl.PushMatrix()
defer gl.PopMatrix()
gl.Translated(gl.Double(x_pos), gl.Double(y), gl.Double(z))
gl.Scaled(gl.Double(scale), gl.Double(scale), 1)
gl.PushAttrib(gl.COLOR_BUFFER_BIT)
defer gl.PopAttrib()
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, gl.Uint(d.texture))
gl.BindBuffer(gl.ARRAY_BUFFER, gl.Uint(strbuf.vbuffer))
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.VertexPointer(2, gl.FLOAT, gl.Sizei(size), nil)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
gl.TexCoordPointer(2, gl.FLOAT, gl.Sizei(size), gl.Pointer(unsafe.Offsetof(strbuf.vs[0].u)))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, gl.Uint(strbuf.ibuffer))
gl.DrawElements(gl.TRIANGLES, gl.Sizei(len(strbuf.is)), gl.UNSIGNED_SHORT, nil)
gl.DisableClientState(gl.VERTEX_ARRAY)
gl.DisableClientState(gl.TEXTURE_COORD_ARRAY)
gl.Disable(gl.TEXTURE_2D)
return
}
x_pos = 0
var prev rune
for _, r := range s {
if _, ok := d.data.Kerning[prev]; ok {
x_pos += float32(d.data.Kerning[prev][r])
}
prev = r
info := d.getInfo(r)
xleft := x_pos + float32(info.Full_bounds.Min.X)
xright := x_pos + float32(info.Full_bounds.Max.X)
ytop := float32(info.Full_bounds.Max.Y) + float32(-d.data.Miny)
ybot := float32(info.Full_bounds.Min.Y) + float32(-d.data.Miny)
start := uint16(len(strbuf.vs))
strbuf.is = append(strbuf.is, start+0)
strbuf.is = append(strbuf.is, start+1)
strbuf.is = append(strbuf.is, start+2)
strbuf.is = append(strbuf.is, start+0)
strbuf.is = append(strbuf.is, start+2)
strbuf.is = append(strbuf.is, start+3)
strbuf.vs = append(strbuf.vs, dictVert{
x: xleft,
y: ytop,
u: float32(info.Pos.Min.X) / float32(d.data.Dx),
v: float32(info.Pos.Max.Y) / float32(d.data.Dy),
})
strbuf.vs = append(strbuf.vs, dictVert{
x: xleft,
y: ybot,
u: float32(info.Pos.Min.X) / float32(d.data.Dx),
v: float32(info.Pos.Min.Y) / float32(d.data.Dy),
})
strbuf.vs = append(strbuf.vs, dictVert{
x: xright,
y: ybot,
u: float32(info.Pos.Max.X) / float32(d.data.Dx),
v: float32(info.Pos.Min.Y) / float32(d.data.Dy),
})
strbuf.vs = append(strbuf.vs, dictVert{
x: xright,
y: ytop,
u: float32(info.Pos.Max.X) / float32(d.data.Dx),
v: float32(info.Pos.Max.Y) / float32(d.data.Dy),
})
x_pos += float32(info.Advance) // - float32((info.Full_bounds.Dx() - info.Bounds.Dx()))
}
gl.GenBuffers(1, (*gl.Uint)(&strbuf.vbuffer))
gl.BindBuffer(gl.ARRAY_BUFFER, gl.Uint(strbuf.vbuffer))
gl.BufferData(gl.ARRAY_BUFFER, gl.Sizeiptr(int(size)*len(strbuf.vs)), gl.Pointer(&strbuf.vs[0].x), gl.STATIC_DRAW)
gl.GenBuffers(1, (*gl.Uint)(&strbuf.ibuffer))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, gl.Uint(strbuf.ibuffer))
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, gl.Sizeiptr(int(unsafe.Sizeof(strbuf.is[0]))*len(strbuf.is)), gl.Pointer(&strbuf.is[0]), gl.STATIC_DRAW)
d.strs[s] = strbuf
}
