No rendering when running on separate goroutine

[bejaneps]

So, basically I'm following justforfunc series, and started to build flappy gopher game. I've run into an issue that after running a renderer in a separate goroutine it doesn't copy texture to window.

Minimal reproduction

1. Build game: go build *.go
2. Run it: ./main
3. Draws only Flappy Gopher title on window, no bird and background.

Goversion: 1.14.4 OS: Elementary OS Juno

Code main.go

package main

import (
    "context"
    "log"
    "os"
    "path/filepath"
    "runtime"
    "time"

    "github.com/pkg/errors"

    "github.com/veandco/go-sdl2/sdl"
    "github.com/veandco/go-sdl2/ttf"
)

var (
    pathToFonts     = filepath.Join("res", "fonts", "flappy.ttf")
    pathToBgImage   = filepath.Join("res", "images", "background.png")
    pathToBirdImage = filepath.Join("res", "images", "bird_frame_%d.png")
)

func main() {
    if err := run(); err != nil {
        log.Println(err)
        os.Exit(2)
    }
}

func run() error {
    var err error

    // initialize all dependencies for SDL
    err = sdl.Init(sdl.INIT_EVERYTHING)
    if err != nil {
        return errors.Errorf("couldn't init SDL: %v", err)
    }
    defer sdl.Quit()

    // initialize fonts that will be used
    err = ttf.Init()
    if err != nil {
        return errors.Errorf("couldn't init TTF: %v", err)
    }
    defer ttf.Quit()

    // create a window
    w, r, err := sdl.CreateWindowAndRenderer(800, 600, sdl.WINDOW_SHOWN)
    if err != nil {
        return errors.Errorf("couldn't create window: %v", err)
    }
    defer r.Destroy()
    defer w.Destroy()

    // draw title
    err = drawTitle(r, "Flappy Gopher")
    if err != nil {
        return errors.Errorf("couldn't draw title: %v", err)
    }

    sdl.Delay(1000)

    // initialize new scene
    scene, err := newScene(r)
    if err != nil {
        return errors.Errorf("couldn't create scene: %v", err)
    }
    defer scene.destroy()

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

        // problem code
    runtime.LockOSThread()
    errc := scene.run(ctx, r)
    for {
        select {
        case err := <-errc:
            return err
        case <-time.After(5 * time.Second):
            return nil
        }
    }
}

func drawTitle(r *sdl.Renderer, title string) error {
    r.Clear()

    // open and load font
    font, err := ttf.OpenFont(pathToFonts, 20)
    if err != nil {
        return errors.Errorf("couldn't open font: %v", err)
    }
    defer font.Close()

    // render title
    c := sdl.Color{R: 255, G: 100, B: 0, A: 255}
    surface, err := font.RenderUTF8Solid(title, c)
    if err != nil {
        return errors.Errorf("couldn't render title")
    }
    defer surface.Free()

    // create texture from rendered title
    texture, err := r.CreateTextureFromSurface(surface)
    if err != nil {
        return errors.Errorf("couldn't create font texture: %v", err)
    }
    defer texture.Destroy()

    err = r.Copy(texture, nil, nil)
    if err != nil {
        return errors.Errorf("coldn't copy font texture: %v", err)
    }

    r.Present()

    return nil
}

scene.go

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/pkg/errors"
    "github.com/veandco/go-sdl2/img"
    "github.com/veandco/go-sdl2/sdl"
)

type scene struct {
    time int

    bg    *sdl.Texture
    birds []*sdl.Texture
}

func newScene(r *sdl.Renderer) (*scene, error) {
    // open and load background image
    bg, err := img.LoadTexture(r, pathToBgImage)
    if err != nil {
        return nil, errors.Errorf("couldn't load background image: %v", err)
    }

    // open and load bird images
    var birds []*sdl.Texture
    for i := 1; i <= 4; i++ {
        path := fmt.Sprintf(pathToBirdImage, i)

        bird, err := img.LoadTexture(r, path)
        if err != nil {
            return nil, errors.Errorf("couldn't load bird image: %v", err)
        }

        birds = append(birds, bird)
    }

    return &scene{bg: bg, birds: birds}, nil
}

// problem method
func (s *scene) run(ctx context.Context, r *sdl.Renderer) <-chan error {
    errc := make(chan error)

    go func() {
        defer close(errc)
        tick := time.Tick(10 * time.Millisecond)
        for {
            select {
            case <-ctx.Done():
                return
            case <-tick:
                if err := s.paint(r); err != nil {
                    errc <- err
                }
            }

        }
    }()

    return errc
}

func (s *scene) paint(r *sdl.Renderer) error {
    s.time++
    r.Clear()

    // copy backround image
    err := r.Copy(s.bg, nil, nil)
    if err != nil {
        return errors.Errorf("couldn't copy background image: %v", err)
    }

    // place bird in the middle of window
    // and draw different bird images every second
    rect := &sdl.Rect{W: 50, H: 43, X: 10, Y: 300 - 43/2}
    i := s.time / 10 % len(s.birds)
    err = r.Copy(s.birds[i], nil, rect)
    if err != nil {
        return errors.Errorf("couldn't copy bird image: %v", err)
    }

    r.Present()

    return nil
}

func (s *scene) destroy() {
    s.bg.Destroy()

    for _, v := range s.birds {
        v.Destroy()
    }
}

Note: I tried to use directly scene.paint() method and it draws background and bird successfully, but when it's running inside scene.run() method, it basically shows black screen.

[bejaneps]

Up

[veeableful]

Hi @bejaneps, sorry for the wait. Could you post a minimal example that reproduces the issue? I don't have all the assets so it would be very helpful if you can share a tiny project that requires no assets and reproduces the same issue so I can see what's going on.

[Noofbiz]

I'm not sure if SDL supports using Renderer.Paint off the main thread. The only things I'm seeing that allow you to do so is via OpenGL contexts, not directly using the Renderer. Here and here are folks doing it with an OpenGL context, but I haven't seen anything using the built in Renderer