Question

我正在使用Go + SDL创建一个简单的节点图编辑器，假定的行为是在右键单击后显示一个rect（现在象征该节点）

我尝试检查是否抛出任何错误（因为我目前忽略了某些函数返回的错误），但是没有错误。

这是什么错误？

游戏结构

type Config struct {
    Title  string
    Width  int32
    Height int32
}

const FPS = 60

type Game struct {
    scene *Scene
    renderer *sdl.Renderer
}

func Run(c *Config) {
    if err := sdl.Init(sdl.INIT_EVERYTHING); err != nil {
        fmt.Println("Initializing sdl: ", err)
        return
    }

    window, err := sdl.CreateWindow(c.Title,
        sdl.WINDOWPOS_CENTERED,
        sdl.WINDOWPOS_CENTERED, c.Width, c.Height,
        sdl.WINDOW_OPENGL)

    if err != nil {
        fmt.Println("Initializing window: ", err)
        return
    }

    defer window.Destroy()

    renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)

    if err != nil {
        fmt.Println("Initializing renderer: ", err)
        return
    }

    defer renderer.Destroy()

    g := Game{
        renderer: renderer,
        scene: NewScene(renderer),
    }

    stop := make(chan struct{})
    go g.Draw(renderer, stop)

    g.HandleInput()
}

func (g *Game) HandleInput() {
loop:
    for {
        ev := sdl.WaitEvent()
        if ev == nil {
            sdl.Delay(1000)
            continue
        }
        switch t := ev.(type) {
        case *sdl.QuitEvent:
            break loop
        case *sdl.KeyboardEvent:
            if t.State == sdl.PRESSED {
                switch ev.(*sdl.KeyboardEvent).Keysym.Sym {
                case sdl.K_q:
                    break loop
                }
            }
        case *sdl.MouseButtonEvent:
            g.scene.HandleMouseInput(ev.(*sdl.MouseButtonEvent))
        }
    }
}

func (g *Game) Draw(r *sdl.Renderer, stop chan struct{}) {
    fps := uint32(FPS)

loop:
    for {
        select {
        case <-stop:
            break loop
        default:
        }
        _ = r.SetDrawColor(0, 0, 0, 255)
        _ = r.Clear()

        g.scene.Draw()

        r.Present()
        sdl.Delay(1000 / fps)
    }
}

场景结构

type Scene struct {
    renderer *sdl.Renderer
    nodes    []structs.Node
}

func NewScene(renderer *sdl.Renderer) *Scene {
    var scene Scene
    scene.renderer = renderer
    scene.nodes = make([]structs.Node, 0)

    return &scene
}

func (s *Scene) Draw() {
    if len(s.nodes) > 0 {
        for _, node := range s.nodes {
            node.Draw()
            fmt.Printf("Drawing node: %+v(%d)\n", node, len(s.nodes))
        }
    }
}

func (s *Scene) HandleMouseInput(ev *sdl.MouseButtonEvent){
    const LeftClick = 1
    const RightClick = 3 //TODO: context menu



    if ev.Type == sdl.MOUSEBUTTONDOWN {
        mouseX, mouseY, state := sdl.GetMouseState()

        if ev.Button == LeftClick {
            s.SpawnNode(mouseX, mouseY)
            fmt.Println(mouseX, mouseY, state)
        }

        if ev.Button == RightClick {
            fmt.Println("Open context menu")
        }
    }
}

func (s *Scene) SpawnNode(x int32, y int32) {
    node := structs.NewNode(x, y, s.renderer)
    s.nodes = append(s.nodes, *node)
}

节点结构

type Node struct {
    Uuid      string
    width     int32
    height    int32
    draggable bool
    position  *Position
    renderer  *sdl.Renderer
}

func NewNode(x int32, y int32, renderer *sdl.Renderer) *Node {
    var n Node

    const DefaultWidth = 200
    const DefaultHeight = 80

    n.position = NewPosition(x, y)
    n.width = DefaultWidth
    n.height = DefaultHeight
    n.renderer = renderer

    uuid, err := helpers.GenerateUUID()

    if err != nil {
        return nil
    }

    n.Uuid = string(uuid)

    return &n
}

func (n *Node) Draw() {
    _ = n.renderer.SetDrawColor(255, 0, 0, 255)
    _ = n.renderer.FillRect(&sdl.Rect{
        X: n.position.x, Y: n.position.y, W: n.width, H: n.height,
    })
}

单击鼠标后未显示矩形

0 个答案: