// SPDX-License-Identifier: Apache-2.0 OR MIT OR Unlicense

// Code auto-generated by piet-gpu-derive

struct CmdCircleRef {
    uint offset;
};

struct CmdLineRef {
    uint offset;
};

struct CmdStrokeRef {
    uint offset;
};

struct CmdFillRef {
    uint offset;
};

struct CmdFillTextureRef {
    uint offset;
};

struct CmdBeginClipRef {
    uint offset;
};

struct CmdBeginSolidClipRef {
    uint offset;
};

struct CmdEndClipRef {
    uint offset;
};

struct CmdSolidRef {
    uint offset;
};

struct CmdSolidTextureRef {
    uint offset;
};

struct CmdSolidMaskRef {
    uint offset;
};

struct CmdJumpRef {
    uint offset;
};

struct CmdRef {
    uint offset;
};

struct CmdCircle {
    vec2 center;
    float radius;
    uint rgba_color;
};

#define CmdCircle_size 16

CmdCircleRef CmdCircle_index(CmdCircleRef ref, uint index) {
    return CmdCircleRef(ref.offset + index * CmdCircle_size);
}

struct CmdLine {
    vec2 start;
    vec2 end;
};

#define CmdLine_size 16

CmdLineRef CmdLine_index(CmdLineRef ref, uint index) {
    return CmdLineRef(ref.offset + index * CmdLine_size);
}

struct CmdStroke {
    uint tile_ref;
    float half_width;
    uint rgba_color;
};

#define CmdStroke_size 12

CmdStrokeRef CmdStroke_index(CmdStrokeRef ref, uint index) {
    return CmdStrokeRef(ref.offset + index * CmdStroke_size);
}

struct CmdFill {
    uint tile_ref;
    int backdrop;
    uint rgba_color;
};

#define CmdFill_size 12

CmdFillRef CmdFill_index(CmdFillRef ref, uint index) {
    return CmdFillRef(ref.offset + index * CmdFill_size);
}

struct CmdFillTexture {
    uint tile_ref;
    int backdrop;
    vec4 mat;
    vec2 translate;
    uvec2 uv_bounds;
};

#define CmdFillTexture_size 40

CmdFillTextureRef CmdFillTexture_index(CmdFillTextureRef ref, uint index) {
    return CmdFillTextureRef(ref.offset + index * CmdFillTexture_size);
}

struct CmdBeginClip {
    uint tile_ref;
    int backdrop;
};

#define CmdBeginClip_size 8

CmdBeginClipRef CmdBeginClip_index(CmdBeginClipRef ref, uint index) {
    return CmdBeginClipRef(ref.offset + index * CmdBeginClip_size);
}

struct CmdBeginSolidClip {
    float alpha;
};

#define CmdBeginSolidClip_size 4

CmdBeginSolidClipRef CmdBeginSolidClip_index(CmdBeginSolidClipRef ref, uint index) {
    return CmdBeginSolidClipRef(ref.offset + index * CmdBeginSolidClip_size);
}

struct CmdEndClip {
    float alpha;
};

#define CmdEndClip_size 4

CmdEndClipRef CmdEndClip_index(CmdEndClipRef ref, uint index) {
    return CmdEndClipRef(ref.offset + index * CmdEndClip_size);
}

struct CmdSolid {
    uint rgba_color;
};

#define CmdSolid_size 4

CmdSolidRef CmdSolid_index(CmdSolidRef ref, uint index) {
    return CmdSolidRef(ref.offset + index * CmdSolid_size);
}

struct CmdSolidTexture {
    vec4 mat;
    vec2 translate;
    uvec2 uv_bounds;
};

#define CmdSolidTexture_size 32

CmdSolidTextureRef CmdSolidTexture_index(CmdSolidTextureRef ref, uint index) {
    return CmdSolidTextureRef(ref.offset + index * CmdSolidTexture_size);
}

struct CmdSolidMask {
    float mask;
};

#define CmdSolidMask_size 4

CmdSolidMaskRef CmdSolidMask_index(CmdSolidMaskRef ref, uint index) {
    return CmdSolidMaskRef(ref.offset + index * CmdSolidMask_size);
}

struct CmdJump {
    uint new_ref;
};

#define CmdJump_size 4

CmdJumpRef CmdJump_index(CmdJumpRef ref, uint index) {
    return CmdJumpRef(ref.offset + index * CmdJump_size);
}

#define Cmd_End 0
#define Cmd_Circle 1
#define Cmd_Line 2
#define Cmd_Fill 3
#define Cmd_FillTexture 4
#define Cmd_BeginClip 5
#define Cmd_BeginSolidClip 6
#define Cmd_EndClip 7
#define Cmd_Stroke 8
#define Cmd_Solid 9
#define Cmd_SolidMask 10
#define Cmd_SolidTexture 11
#define Cmd_Jump 12
#define Cmd_size 44

CmdRef Cmd_index(CmdRef ref, uint index) {
    return CmdRef(ref.offset + index * Cmd_size);
}

CmdCircle CmdCircle_read(Alloc a, CmdCircleRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    uint raw3 = read_mem(a, ix + 3);
    CmdCircle s;
    s.center = vec2(uintBitsToFloat(raw0), uintBitsToFloat(raw1));
    s.radius = uintBitsToFloat(raw2);
    s.rgba_color = raw3;
    return s;
}

void CmdCircle_write(Alloc a, CmdCircleRef ref, CmdCircle s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.center.x));
    write_mem(a, ix + 1, floatBitsToUint(s.center.y));
    write_mem(a, ix + 2, floatBitsToUint(s.radius));
    write_mem(a, ix + 3, s.rgba_color);
}

CmdLine CmdLine_read(Alloc a, CmdLineRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    uint raw3 = read_mem(a, ix + 3);
    CmdLine s;
    s.start = vec2(uintBitsToFloat(raw0), uintBitsToFloat(raw1));
    s.end = vec2(uintBitsToFloat(raw2), uintBitsToFloat(raw3));
    return s;
}

void CmdLine_write(Alloc a, CmdLineRef ref, CmdLine s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.start.x));
    write_mem(a, ix + 1, floatBitsToUint(s.start.y));
    write_mem(a, ix + 2, floatBitsToUint(s.end.x));
    write_mem(a, ix + 3, floatBitsToUint(s.end.y));
}

CmdStroke CmdStroke_read(Alloc a, CmdStrokeRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    CmdStroke s;
    s.tile_ref = raw0;
    s.half_width = uintBitsToFloat(raw1);
    s.rgba_color = raw2;
    return s;
}

void CmdStroke_write(Alloc a, CmdStrokeRef ref, CmdStroke s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.tile_ref);
    write_mem(a, ix + 1, floatBitsToUint(s.half_width));
    write_mem(a, ix + 2, s.rgba_color);
}

CmdFill CmdFill_read(Alloc a, CmdFillRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    CmdFill s;
    s.tile_ref = raw0;
    s.backdrop = int(raw1);
    s.rgba_color = raw2;
    return s;
}

void CmdFill_write(Alloc a, CmdFillRef ref, CmdFill s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.tile_ref);
    write_mem(a, ix + 1, uint(s.backdrop));
    write_mem(a, ix + 2, s.rgba_color);
}

CmdFillTexture CmdFillTexture_read(Alloc a, CmdFillTextureRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    uint raw3 = read_mem(a, ix + 3);
    uint raw4 = read_mem(a, ix + 4);
    uint raw5 = read_mem(a, ix + 5);
    uint raw6 = read_mem(a, ix + 6);
    uint raw7 = read_mem(a, ix + 7);
    uint raw8 = read_mem(a, ix + 8);
    uint raw9 = read_mem(a, ix + 9);
    CmdFillTexture s;
    s.tile_ref = raw0;
    s.backdrop = int(raw1);
    s.mat = vec4(uintBitsToFloat(raw2), uintBitsToFloat(raw3), uintBitsToFloat(raw4), uintBitsToFloat(raw5));
    s.translate = vec2(uintBitsToFloat(raw6), uintBitsToFloat(raw7));
    s.uv_bounds = uvec2(raw8, raw9);
    return s;
}

void CmdFillTexture_write(Alloc a, CmdFillTextureRef ref, CmdFillTexture s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.tile_ref);
    write_mem(a, ix + 1, uint(s.backdrop));
    write_mem(a, ix + 2, floatBitsToUint(s.mat.x));
    write_mem(a, ix + 3, floatBitsToUint(s.mat.y));
    write_mem(a, ix + 4, floatBitsToUint(s.mat.z));
    write_mem(a, ix + 5, floatBitsToUint(s.mat.w));
    write_mem(a, ix + 6, floatBitsToUint(s.translate.x));
    write_mem(a, ix + 7, floatBitsToUint(s.translate.y));
    write_mem(a, ix + 8, s.uv_bounds.x);
    write_mem(a, ix + 9, s.uv_bounds.y);
}

CmdBeginClip CmdBeginClip_read(Alloc a, CmdBeginClipRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    CmdBeginClip s;
    s.tile_ref = raw0;
    s.backdrop = int(raw1);
    return s;
}

void CmdBeginClip_write(Alloc a, CmdBeginClipRef ref, CmdBeginClip s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.tile_ref);
    write_mem(a, ix + 1, uint(s.backdrop));
}

CmdBeginSolidClip CmdBeginSolidClip_read(Alloc a, CmdBeginSolidClipRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    CmdBeginSolidClip s;
    s.alpha = uintBitsToFloat(raw0);
    return s;
}

void CmdBeginSolidClip_write(Alloc a, CmdBeginSolidClipRef ref, CmdBeginSolidClip s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.alpha));
}

CmdEndClip CmdEndClip_read(Alloc a, CmdEndClipRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    CmdEndClip s;
    s.alpha = uintBitsToFloat(raw0);
    return s;
}

void CmdEndClip_write(Alloc a, CmdEndClipRef ref, CmdEndClip s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.alpha));
}

CmdSolid CmdSolid_read(Alloc a, CmdSolidRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    CmdSolid s;
    s.rgba_color = raw0;
    return s;
}

void CmdSolid_write(Alloc a, CmdSolidRef ref, CmdSolid s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.rgba_color);
}

CmdSolidTexture CmdSolidTexture_read(Alloc a, CmdSolidTextureRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    uint raw1 = read_mem(a, ix + 1);
    uint raw2 = read_mem(a, ix + 2);
    uint raw3 = read_mem(a, ix + 3);
    uint raw4 = read_mem(a, ix + 4);
    uint raw5 = read_mem(a, ix + 5);
    uint raw6 = read_mem(a, ix + 6);
    uint raw7 = read_mem(a, ix + 7);
    CmdSolidTexture s;
    s.mat = vec4(uintBitsToFloat(raw0), uintBitsToFloat(raw1), uintBitsToFloat(raw2), uintBitsToFloat(raw3));
    s.translate = vec2(uintBitsToFloat(raw4), uintBitsToFloat(raw5));
    s.uv_bounds = uvec2(raw6, raw7);
    return s;
}

void CmdSolidTexture_write(Alloc a, CmdSolidTextureRef ref, CmdSolidTexture s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.mat.x));
    write_mem(a, ix + 1, floatBitsToUint(s.mat.y));
    write_mem(a, ix + 2, floatBitsToUint(s.mat.z));
    write_mem(a, ix + 3, floatBitsToUint(s.mat.w));
    write_mem(a, ix + 4, floatBitsToUint(s.translate.x));
    write_mem(a, ix + 5, floatBitsToUint(s.translate.y));
    write_mem(a, ix + 6, s.uv_bounds.x);
    write_mem(a, ix + 7, s.uv_bounds.y);
}

CmdSolidMask CmdSolidMask_read(Alloc a, CmdSolidMaskRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    CmdSolidMask s;
    s.mask = uintBitsToFloat(raw0);
    return s;
}

void CmdSolidMask_write(Alloc a, CmdSolidMaskRef ref, CmdSolidMask s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, floatBitsToUint(s.mask));
}

CmdJump CmdJump_read(Alloc a, CmdJumpRef ref) {
    uint ix = ref.offset >> 2;
    uint raw0 = read_mem(a, ix + 0);
    CmdJump s;
    s.new_ref = raw0;
    return s;
}

void CmdJump_write(Alloc a, CmdJumpRef ref, CmdJump s) {
    uint ix = ref.offset >> 2;
    write_mem(a, ix + 0, s.new_ref);
}

uint Cmd_tag(Alloc a, CmdRef ref) {
    return read_mem(a, ref.offset >> 2);
}

CmdCircle Cmd_Circle_read(Alloc a, CmdRef ref) {
    return CmdCircle_read(a, CmdCircleRef(ref.offset + 4));
}

CmdLine Cmd_Line_read(Alloc a, CmdRef ref) {
    return CmdLine_read(a, CmdLineRef(ref.offset + 4));
}

CmdFill Cmd_Fill_read(Alloc a, CmdRef ref) {
    return CmdFill_read(a, CmdFillRef(ref.offset + 4));
}

CmdFillTexture Cmd_FillTexture_read(Alloc a, CmdRef ref) {
    return CmdFillTexture_read(a, CmdFillTextureRef(ref.offset + 4));
}

CmdBeginClip Cmd_BeginClip_read(Alloc a, CmdRef ref) {
    return CmdBeginClip_read(a, CmdBeginClipRef(ref.offset + 4));
}

CmdBeginSolidClip Cmd_BeginSolidClip_read(Alloc a, CmdRef ref) {
    return CmdBeginSolidClip_read(a, CmdBeginSolidClipRef(ref.offset + 4));
}

CmdEndClip Cmd_EndClip_read(Alloc a, CmdRef ref) {
    return CmdEndClip_read(a, CmdEndClipRef(ref.offset + 4));
}

CmdStroke Cmd_Stroke_read(Alloc a, CmdRef ref) {
    return CmdStroke_read(a, CmdStrokeRef(ref.offset + 4));
}

CmdSolid Cmd_Solid_read(Alloc a, CmdRef ref) {
    return CmdSolid_read(a, CmdSolidRef(ref.offset + 4));
}

CmdSolidMask Cmd_SolidMask_read(Alloc a, CmdRef ref) {
    return CmdSolidMask_read(a, CmdSolidMaskRef(ref.offset + 4));
}

CmdSolidTexture Cmd_SolidTexture_read(Alloc a, CmdRef ref) {
    return CmdSolidTexture_read(a, CmdSolidTextureRef(ref.offset + 4));
}

CmdJump Cmd_Jump_read(Alloc a, CmdRef ref) {
    return CmdJump_read(a, CmdJumpRef(ref.offset + 4));
}

void Cmd_End_write(Alloc a, CmdRef ref) {
    write_mem(a, ref.offset >> 2, Cmd_End);
}

void Cmd_Circle_write(Alloc a, CmdRef ref, CmdCircle s) {
    write_mem(a, ref.offset >> 2, Cmd_Circle);
    CmdCircle_write(a, CmdCircleRef(ref.offset + 4), s);
}

void Cmd_Line_write(Alloc a, CmdRef ref, CmdLine s) {
    write_mem(a, ref.offset >> 2, Cmd_Line);
    CmdLine_write(a, CmdLineRef(ref.offset + 4), s);
}

void Cmd_Fill_write(Alloc a, CmdRef ref, CmdFill s) {
    write_mem(a, ref.offset >> 2, Cmd_Fill);
    CmdFill_write(a, CmdFillRef(ref.offset + 4), s);
}

void Cmd_FillTexture_write(Alloc a, CmdRef ref, CmdFillTexture s) {
    write_mem(a, ref.offset >> 2, Cmd_FillTexture);
    CmdFillTexture_write(a, CmdFillTextureRef(ref.offset + 4), s);
}

void Cmd_BeginClip_write(Alloc a, CmdRef ref, CmdBeginClip s) {
    write_mem(a, ref.offset >> 2, Cmd_BeginClip);
    CmdBeginClip_write(a, CmdBeginClipRef(ref.offset + 4), s);
}

void Cmd_BeginSolidClip_write(Alloc a, CmdRef ref, CmdBeginSolidClip s) {
    write_mem(a, ref.offset >> 2, Cmd_BeginSolidClip);
    CmdBeginSolidClip_write(a, CmdBeginSolidClipRef(ref.offset + 4), s);
}

void Cmd_EndClip_write(Alloc a, CmdRef ref, CmdEndClip s) {
    write_mem(a, ref.offset >> 2, Cmd_EndClip);
    CmdEndClip_write(a, CmdEndClipRef(ref.offset + 4), s);
}

void Cmd_Stroke_write(Alloc a, CmdRef ref, CmdStroke s) {
    write_mem(a, ref.offset >> 2, Cmd_Stroke);
    CmdStroke_write(a, CmdStrokeRef(ref.offset + 4), s);
}

void Cmd_Solid_write(Alloc a, CmdRef ref, CmdSolid s) {
    write_mem(a, ref.offset >> 2, Cmd_Solid);
    CmdSolid_write(a, CmdSolidRef(ref.offset + 4), s);
}

void Cmd_SolidMask_write(Alloc a, CmdRef ref, CmdSolidMask s) {
    write_mem(a, ref.offset >> 2, Cmd_SolidMask);
    CmdSolidMask_write(a, CmdSolidMaskRef(ref.offset + 4), s);
}

void Cmd_SolidTexture_write(Alloc a, CmdRef ref, CmdSolidTexture s) {
    write_mem(a, ref.offset >> 2, Cmd_SolidTexture);
    CmdSolidTexture_write(a, CmdSolidTextureRef(ref.offset + 4), s);
}

void Cmd_Jump_write(Alloc a, CmdRef ref, CmdJump s) {
    write_mem(a, ref.offset >> 2, Cmd_Jump);
    CmdJump_write(a, CmdJumpRef(ref.offset + 4), s);
}