Trying to render quads in Atomic

Quads.cs

using System;
using AtomicEngine;

public class GameRoot : AppDelegate
{
    private Texture2D sprite;

    public override void Start()
    {
        var graphics = AtomicNET.GetSubsystem<Graphics>();

        pixelShader = graphics.GetShader(ShaderType.PS, "Atomic2D");
        vertexShader = graphics.GetShader(ShaderType.VS, "Atomic2D");
        vertexBuffer = new VertexBuffer();
        vertexBuffer.SetSize(quadsQty*6, Constants.MASK_POSITION | Constants.MASK_COLOR | Constants.MASK_TEXCOORD1, true);

        var renderer = AtomicNET.GetSubsystem<Renderer>();
        var viewport = renderer.GetViewport(0);
            
        var cache = GetSubsystem<ResourceCache>();
        sprite = cache.GetResource<Texture2D>("Sprites/Sprite.png");

        var renderpath = viewport.GetRenderPath().Clone();
        renderpath.Append(cache.GetResource<XMLFile>("RenderPath/RenderPath.xml"));
        viewport.SetRenderPath(renderpath);

        graphics.SetShaders(vertexShader, pixelShader);
        graphics.SetShaderParameter(ShaderParams.VSP_MODEL, Matrix3x4.IDENTITY);
        graphics.SetShaderParameter(ShaderParams.PSP_MATDIFFCOLOR, Color.White);
        graphics.SetCullMode(CullMode.CULL_NONE);

        var scene = new Scene();
        scene.CreateComponent<Octree>();

        camera = scene.CreateChild("cam").CreateComponent<Camera>();
        camera.Node.Position = new Vector3(graphics.Width / 2.0f, graphics.Height / 2.0f, 0.0f);
        camera.Orthographic = true;
        camera.OrthoSize = graphics.Height;

        viewport.Scene = scene;
        viewport.Camera = camera;
            
        SubscribeToEvent("Update", (u,e) => { Update(); });
        SubscribeToEvent("RenderPathEvent", (u, e) => { Render(); });
    }

    void Update(){}

    uint quadsQty = 1000;
    VertexBuffer vertexBuffer;
    ShaderVariation pixelShader;
    ShaderVariation vertexShader;

    private Camera camera;
    Random rng = new Random();

    unsafe void Render()
    {
        IntPtr vertexData = vertexBuffer.Lock(0, quadsQty*6, true); {
            float* vout = (float*) vertexData;
            for (uint i = 0; i < quadsQty; i++)
            {
                float x = rng.Next(1000);
                float y = rng.Next(500);

                //x,y,z,c,u,v
                *vout++ = x;
                *vout++ = y;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 0;
                *vout++ = 0;

                *vout++ = x;
                *vout++ = y+16;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 0;
                *vout++ = 1;

                *vout++ = x+16;
                *vout++ = y;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 1;
                *vout++ = 0;

                *vout++ = x+16;
                *vout++ = y;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 1;
                *vout++ = 0;

                *vout++ = x;
                *vout++ = y+16;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 0;
                *vout++ = 1;

                *vout++ = x+16;
                *vout++ = y+16;
                *vout++ = 0;
                *vout++ = 0xFFFFFFFF;
                *vout++ = 1;
                *vout++ = 1;
            }
        } vertexBuffer.Unlock();

        AtomicNET.GetSubsystem<Renderer>().GetViewport(0).View.SetCameraShaderParameters(camera);

        var graphics = AtomicNET.GetSubsystem<Graphics>();
        graphics.SetDefaultTextureFilterMode(TextureFilterMode.FILTER_NEAREST);
        graphics.SetBlendMode(BlendMode.BLEND_ALPHA);
            
        graphics.Clear(0x1, Color.White);
            
        graphics.SetTexture((uint)TextureUnit.TU_DIFFUSE, sprite);
        graphics.SetVertexBuffer(vertexBuffer);
        graphics.Draw(PrimitiveType.TRIANGLE_LIST, 0, quadsQty*6);
    }
}