Confusing problem with fields vs local variables and rendering (OpenGL)

[TheToblexson]

I'm trying to learn/implement OpenGL and I've got a rendering framework functioning. I can add a shape to the render list from my Layer update method, and I can add a shape from a collection from within that update method, but if I try to add a shape from a class field it is not rendered.

My guess is that this has something to do with addresses/pointers, and OpenGL not getting the array that Visual Studio is telling me it is, but I don't have a perfect understanding of OpenGL or rendering in general, so I could be completely wrong, and either way, I don't know how to further troubleshoot it. I'm definitely sharing some excess code, but I don't want to cut any methods from these files in case they actually do end up being the cause. The phantom types (like RenderQuad) are mostly just helper structs or struct-like classes and really shouldn't be causing this problem.

I also doubt that my method of subbuffering is efficient, but I thought it was at least working until now.

Sorry if this is the wrong place to ask, or if I've formatted this question attrociously.
I've removed a lot of comments, summary tags and regions to streamline the pasted code, so there might be some random half comments or half regions that I missed.

Update: It isn't lists that are causing the problem, rather fields vs locally defined variables. If I define a button in the Update method, then it renders. However, if the same variable is instead a class field it is not rendered, apart from a split second flash that might be the very first render call. I really have no clue here.

Layer Class

public class Layer
{
    private IWindow _window;
    private Renderer _renderer;
    private static InputHandler _input;
    private static List<Component> _components = [];

    private float WindowTop => _window.Size.Y;
    private float WindowBottom => 0;
    private float WindowRight => _window.Size.X;
    private float WindowLeft => 0;

    public Layer(Renderer renderer, InputHandler inputHandler)
    {
        _window = renderer.Window;
        _renderer = renderer;
        _input = inputHandler;
    }

    public void Update()
    {
        var taskbarPanel = new Panel("TaskbarPanel", WindowLeft, WindowTop - 30f, 0f, WindowRight, 30f, Color.Black);
        var fileButton = new Panel("FileButton", WindowLeft + 5f, WindowTop - 25f, 0f, 50f, 20f, Color.Red);
        var editButton = new Panel("EditButton", WindowLeft + 55f, WindowTop - 25f, 0f, 50f, 20f, Color.Green);
        var viewButton = new Panel("ViewButton", WindowLeft + 105f, WindowTop - 25f, 0f, 50f, 20f, Color.Blue);

        // This works
        _renderer.AddShape(taskbarPanel.Name, taskbarPanel.Quad);
        _renderer.AddShape(fileButton.Name, fileButton.Quad);
        _renderer.AddShape(editButton.Name, editButton.Quad);
        _renderer.AddShape(viewButton.Name, viewButton.Quad);

        // This works
        //List<Component> componentsLocal = [];
        //componentsLocal.Add(fileButton);
        //_renderer.AddShape(componentsLocal[0].Name, componentsLocal[0].Quad);

        // This doesn't work
        //_componentsField.Add(editButton);
        //_renderer.AddShape(_components[0].Name, _components[0].Quad);

        // this doesn't work
        //Component[] copy = new Component[_components.Count];
        //Array.Copy(_components.ToArray(), copy, _components.Count);
        //_renderer.AddShape(copy[0].Name, copy[0].Quad);
    }
}

Renderer Class

public class Renderer
{
    private static uint AttributesCount { get; set; } = 0;
    private static nint AttributesPointer { get; set; } = 0;
    private Dictionary<string, RenderShape> Shapes { get; } = [];
    private uint VertexCount { get; set; } = 0;

    public IWindow Window { get; }
    public GL OpenGL { get; }
    public VertexArray VertexArray { get; }
    public VertexBuffer VertexBuffer { get; }
    public IndexBuffer IndexBuffer { get; }
    public Shader Shader { get; }

    public Renderer(IWindow mainWindow, string shaderFileName)
    {
        Window = mainWindow;
        OpenGL = Window.CreateOpenGL();

        OpenGL.ClearColor(Color.Gray);

        VertexArray = new VertexArray(OpenGL);
        VertexArray.Bind();

        VertexBuffer = new VertexBuffer(OpenGL, RenderVertex.Size * 1000);
        VertexBuffer.Bind();

        IndexBuffer = new IndexBuffer(OpenGL, sizeof(uint) * 1000);
        IndexBuffer.Bind();

        Shader = new Shader(OpenGL, "Basic.shader", 8, Window.Size);

        AddAttribute(3, 4, 2, 1);

        Unbind();
    }

    private void AddAttribute(uint count)
    {
        OpenGL.VertexAttribPointer(AttributesCount, (int)count, VertexAttribPointerType.Float, false, RenderVertex.Size, AttributesPointer);
        OpenGL.EnableVertexAttribArray(AttributesCount);
        AttributesCount += 1;
        AttributesPointer += (nint)(count * sizeof(float));
    }

    private void AddAttribute(params uint[] counts)
    {
        foreach (uint count in counts)
            AddAttribute(count);
    }

    private void Unbind()
    {
        VertexArray.Unbind();
        VertexBuffer.Unbind();
        IndexBuffer.Unbind();
        Shader.Unbind();
    }

    private void Bind()
    {
        VertexArray.Bind();
        VertexBuffer.Bind();
        IndexBuffer.Bind();
        Shader.Bind();
    }

    public void BindTexture(string fileNmae, uint slotIndex)
    {
        Shader.Bind();
        Shader.BindTexture(fileNmae, slotIndex);
        Shader.Unbind();
    }

    public void AddShape(string name, RenderShape shape)
    {
        shape.OffsetIndices(VertexCount);

        VertexCount += shape.VertexCount;

        Shapes.TryAdd(name, shape);
    }

    public void Update()
    {
        List<float> vertices = [];
        List<uint> indices = [];

        foreach (RenderShape shape in Shapes.Values)
        {
            vertices.AddRange(shape.Vertices);
            indices.AddRange(shape.Indices);
        }
        VertexBuffer.BufferSubData(vertices.ToArray());
        IndexBuffer.BufferSubData(indices.ToArray());
    }

    public unsafe void Render()
    {
        Bind();
        OpenGL.Clear(ClearBufferMask.ColorBufferBit);

        uint indicesCount = 0;
        foreach (var shape in Shapes.Values)
            indicesCount += (uint)shape.Indices.Count;

        OpenGL.DrawElements(PrimitiveType.Triangles, indicesCount, DrawElementsType.UnsignedInt, null);
        Unbind();
    }

    public void Delete()
    {
        // Delete all the buffers.
        VertexBuffer.Delete();
        IndexBuffer.Delete();
        VertexArray.Delete();
        Shader.Delete();
    }
}

Application Class

public class Application
{
    private IWindow _window;
    private Renderer _renderer;
    private Dictionary<string,Layer> _layers = [];

    public Application()

    {
        WindowOptions options = WindowOptions.Default with
        {
            Size = new(800, 600),
            Title = "Notator"
        };
        _window = Window.Create(options);

        _window.Load += OnLoad;
        _window.Update += OnUpdate;
        _window.Render += OnRender;
        _window.Closing += OnClosing;

        _window.Run();
    }

    private unsafe void OnLoad()
    {
        _renderer = new Renderer(_window, "Basic.shader");

        _renderer.BindTexture("silk.png",  0);
        _renderer.BindTexture("silk2.png", 1);

        InputHandler inputHandler = new InputHandler(_window);

        _layers.Add("Taskbar", new Layer(_renderer, inputHandler));
    }

    private void OnUpdate(double deltaTime)
    {
        foreach (Layer layer in _layers.Values)
        {
            layer.Update();
        }
        _renderer.Update();
    }

    private unsafe void OnRender(double deltaTime)
    {
        _renderer.Render();
    }

    private void OnClosing()
    {
        _renderer.Delete();
    }
}