单击鼠标后未显示矩形

I'm creating a simple node graph editor with Go + SDL and the supposed behavior is to display a rect (it symbolizes the node for now) after right clicking

I've tried to check if there was any error being thrown (since I'm currently ignoring the errors returned by some functions) but there was none errors.

What can be the error here?

Game Struct

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)
    }
}

Scene Struct

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)
", 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)
}

Node Struct

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,
    })
}