module gfx.gl3.queue;

package:

import gfx.bindings.opengl.gl;
import gfx.core.rc : Disposable;
import gfx.gl3 : gfxGlLog;
import gfx.graal.cmd;
import gfx.graal.queue;

final class GlQueue : Queue, Disposable
{
    import gfx.gl3 : GlInfo, GlShare;
    import gfx.graal.device : Device;
    import gfx.graal.sync : Fence, Semaphore;

    private GlShare share;
    private GlInfo info;
    private Device _device;
    private GLuint readFbo;
    private GLuint vao;
    private GlState state;

    this(GlShare share, Device device) {
        this.share = share;
        this.info = share.info;
        _device = device;
        auto gl = share.gl;
        gl.GenFramebuffers(1, &readFbo);
        gl.GenVertexArrays(1, &vao);
        gl.BindVertexArray(vao);
    }

    override void dispose() {
        auto gl = share.gl;
        gl.DeleteFramebuffers(1, &readFbo);
        gl.DeleteVertexArrays(1, &vao);
    }

    override @property Device device() {
        return _device;
    }

    override void waitIdle() {}

    override void submit(Submission[] submissions, Fence fence) {
        auto gl = share.gl;
        foreach (ref s; submissions) {
            foreach (cmdBuf; s.cmdBufs) {
                auto glCmdBuf = cast(GlCommandBuffer)cmdBuf;
                foreach (cmd; glCmdBuf._cmds) {
                    cmd.execute(this, gl);
                }
                if (!glCmdBuf._persistent) {
                    glCmdBuf._cmds.length = 0;
                }
            }
        }
    }

    override void present(Semaphore[] waitSems, PresentRequest[] prs) {
        import gfx.gl3.resource : GlImage, GlImgType;
        import gfx.gl3.swapchain : GlSurface, GlSwapchain;
        auto gl = share.gl;

        foreach (i, pr; prs) {
            auto sc = cast(GlSwapchain)pr.swapChain;
            auto surf = sc.surface;
            auto img = cast(GlImage)sc.images[pr.imageIndex];
            auto size = sc.size;

            share.ctx.makeCurrent(surf.handle);

            if (i == prs.length-1) share.ctx.swapInterval = 1;
            else share.ctx.swapInterval = 0;

            import gfx.gl3.error : glCheck;

            gl.BindFramebuffer(GL_READ_FRAMEBUFFER, readFbo);
            final switch (img.glType) {
            case GlImgType.renderBuf:
                gl.FramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, img.name);
                break;
            case GlImgType.tex:
                gl.FramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, img.name, 0);
                break;
            }

            gl.BindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
            gl.BlitFramebuffer(0, 0, size[0], size[1], 0, 0, size[0], size[1],
                               GL_COLOR_BUFFER_BIT, GL_NEAREST);
            glCheck(gl, "blit framebuffer");

            share.ctx.swapBuffers(surf.handle);
        }
    }
}

final class GlCommandPool : CommandPool
{
    import gfx.core.rc : atomicRcCode;
    import gfx.gl3 : GlShare;
    import gfx.graal.cmd : CommandBuffer;

    mixin(atomicRcCode);

    private GlQueue queue;
    private GlShare share;
    private GLuint fbo;

    this(GlQueue queue) {
        this.queue = queue;
        this.share = queue.share;
        auto gl = share.gl;
        gl.GenFramebuffers(1, &fbo);
    }
    override void dispose() {
        auto gl = share.gl;
        gl.DeleteFramebuffers(1, &fbo);
    }

    override void reset() {}

    override CommandBuffer[] allocate(size_t count) {
        auto bufs = new CommandBuffer[count];
        foreach (i; 0 .. count) {
            bufs[i] = new GlCommandBuffer(this, fbo);
        }
        return bufs;
    }

    override void free(CommandBuffer[] buffers) {}
}

final class GlCommandBuffer : CommandBuffer
{
    import gfx.gl3 : GlShare, GlInfo;
    import gfx.gl3.conv : toGl;
    import gfx.gl3.pipeline : GlPipeline, GlRenderPass;
    import gfx.graal.buffer : Buffer, IndexType;
    import gfx.graal.image : ImageBase, ImageLayout, ImageSubresourceRange;
    import gfx.graal.pipeline : ColorBlendInfo, DepthInfo, DescriptorSet,
                                Pipeline, PipelineLayout, Rasterizer,
                                ShaderStage, VertexInputBinding,
                                VertexInputAttrib, ViewportConfig;
    import gfx.graal.renderpass : Framebuffer, RenderPass;
    import gfx.graal.types : Rect, Trans, Viewport;
    import std.typecons : Flag;

    private enum Dirty {
        none                = 0x00,
        vertexBindings      = 0x01,
        pipeline            = 0x02,

        all                 = 0xff,
    }

    private CommandPool _pool;
    private GLuint _fbo;
    private bool _persistent;

    private GlCommand[] _cmds;
    private Dirty _dirty;

    // render pass cache
    private GlRenderPass _renderPass;
    private GlColorAttachment[] _attachments; // TODO: static array
    private uint _subpass;

    // pipeline cache
    private GLenum _primitive;
    private VertexInputBinding[] _inputBindings;
    private VertexInputAttrib[] _inputAttribs;

    // index buffer cache
    private size_t _indexOffset;
    private GLenum _indexType;

    // vertex cache
    private VertexBinding[] _vertexBindings;


    this (CommandPool pool, GLuint fbo) {
        _pool = pool;
        _fbo = fbo;
    }

    override @property CommandPool pool() {
        return _pool;
    }

    override void reset() {
        _cmds.length = 0;
        _dirty = Dirty.none;
        _vertexBindings.length = 0;
    }

    override void begin(Flag!"persistent" persistent) {
        _persistent = persistent;
    }
    override void end() {}

    override void pipelineBarrier(Trans!PipelineStage stageTrans,
                                  BufferMemoryBarrier[] bufMbs,
                                  ImageMemoryBarrier[] imgMbs)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void clearColorImage(ImageBase image, ImageLayout layout,
                                  in ClearColorValues clearValues,
                                  ImageSubresourceRange[] ranges)
    {
        import gfx.gl3.resource : GlImage;
        _cmds ~= new SetupFramebufferCmd(_fbo, cast(GlImage)image);
        _cmds ~= new ClearColorCmd(clearValues);
    }

    override void clearDepthStencilImage(ImageBase image, ImageLayout layout,
                                         in ClearDepthStencilValues clearValues,
                                         ImageSubresourceRange[] ranges)
    {
        import gfx.gl3.resource : GlImage;
        _cmds ~= new SetupFramebufferCmd(_fbo, cast(GlImage)image);
        _cmds ~= new ClearDepthStencilCmd(clearValues, true, true);
    }

    override void fillBuffer(Buffer dst, in size_t offset, in size_t size, uint value)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void updateBuffer(Buffer dst, in size_t offset, in uint[] data)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void copyBuffer(Trans!Buffer buffers, in CopyRegion[] regions)
    {
        import gfx.gl3.resource : GlBuffer;
        foreach (r; regions) {
            _cmds ~= new CopyBufToBufCmd(
                cast(GlBuffer)buffers.from, cast(GlBuffer)buffers.to, r
            );
        }
    }

    override void copyBufferToImage(Buffer srcBuffer, ImageBase dstImage,
                                    in ImageLayout dstLayout,
                                    in BufferImageCopy[] regions)
    {
        import gfx.gl3.resource : GlBuffer, GlImage;
        foreach (r; regions) {
            _cmds ~= new CopyBufToImgCmd(
                cast(GlBuffer)srcBuffer, cast(GlImage)dstImage, r
            );
        }
    }

    override void setViewport(in uint firstViewport, in Viewport[] viewports)
    {
        _cmds ~= new SetViewportsCmd(firstViewport, viewports);
    }

    override void setScissor(in uint firstScissor, in Rect[] scissors)
    {
        _cmds ~= new SetScissorsCmd(firstScissor, scissors);
    }

    override void setDepthBounds(in float minDepth, in float maxDepth)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    void setLineWidth(in float lineWidth)
    {
        _cmds ~= new SetLineWidthCmd(lineWidth);
    }

    override void setDepthBias(in float constFactor, in float clamp, in float slopeFactor)
    {
        _cmds ~= new SetDepthBiasCmd(constFactor, clamp, slopeFactor);
    }

    override void setStencilCompareMask(in StencilFace faceMask, in uint compareMask)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void setStencilWriteMask(in StencilFace faceMask, in uint writeMask)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void setStencilReference(in StencilFace faceMask, in uint reference)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void setBlendConstants(in float[4] blendConstants)
    {
        _cmds ~= new SetBlendConstantsCmd(blendConstants);
    }

    override void beginRenderPass(RenderPass rp, Framebuffer fb,
                                  Rect area, ClearValues[] clearValues)
    {
        import gfx.gl3.pipeline : GlFramebuffer;
        import gfx.graal.pipeline : ColorBlendAttachment;
        import std.algorithm : map;
        import std.array : array;

        _renderPass = cast(GlRenderPass)rp;
        _attachments = _renderPass.attachments.map!(
            ad => GlColorAttachment(false, ad, ColorBlendAttachment.init)
        ).array;
        setActiveSubpass(0);

        const glFb = cast(GlFramebuffer)fb;
        _cmds ~= new BindFramebufferCmd(glFb.name);
        foreach (cv; clearValues) {
            if (cv.type == ClearValues.Type.color) {
                _cmds ~= new ClearColorCmd(cv.values.color);
            }
            if (cv.type == ClearValues.Type.depthStencil) {
                _cmds ~= new ClearDepthStencilCmd(cv.values.depthStencil, true, true);
            }
        }
    }

    override void nextSubpass()
    {
        setActiveSubpass(_subpass+1);
    }

    override void endRenderPass()
    {}

    override void bindPipeline(Pipeline pipeline)
    {
        auto glPipeline = cast(GlPipeline)pipeline;

        _cmds ~= new BindProgramCmd(glPipeline.prog);
        _cmds ~= new SetViewportConfigsCmd(glPipeline.info.viewports);
        _cmds ~= new SetRasterizerCmd(glPipeline.info.rasterizer);
        _cmds ~= new SetDepthInfoCmd(glPipeline.info.depthInfo);
        _cmds ~= new SetStencilInfoCmd(glPipeline.info.stencilInfo);

        uint curAttach = 0;
        foreach (ref a; _attachments) {
            if (a.enabled) {
                a.attachment = glPipeline.info.blendInfo.attachments[curAttach++];
            }
        }
        assert(curAttach == glPipeline.info.blendInfo.attachments.length);
        _cmds ~= new BindBlendSlotsCmd(_attachments.dup);

        _primitive = toGl(glPipeline.info.assembly.primitive);
        _inputBindings = glPipeline.info.inputBindings;
        _inputAttribs = glPipeline.info.inputAttribs;

        dirty(Dirty.vertexBindings | Dirty.pipeline);
    }

    override void bindVertexBuffers(uint firstBinding, VertexBinding[] bindings)
    {
        const minLen = firstBinding + bindings.length;
        if (_vertexBindings.length < minLen) _vertexBindings.length = minLen;
        _vertexBindings[firstBinding .. firstBinding+bindings.length] = bindings;
        dirty(Dirty.vertexBindings);
    }

    override void bindIndexBuffer(Buffer indexBuf, size_t offset,
                                  IndexType type)
    {
        import gfx.gl3.resource : GlBuffer;
        auto glBuf = cast(GlBuffer)indexBuf;
        _cmds ~= new BindIndexBufCmd(glBuf.name);
        _indexOffset = offset;
        _indexType = toGl(type);
    }

    override void bindDescriptorSets(PipelineBindPoint bindPoint,
                                     PipelineLayout layout, uint firstSet,
                                     DescriptorSet[] sets,
                                     in size_t[] dynamicOffsets)
    {
        import gfx.gl3.pipeline : GlDescriptorSet;
        import gfx.graal.pipeline : DescriptorType;

        size_t dynInd = 0;

        foreach (si, ds; sets) {
            auto glSet = cast(GlDescriptorSet)ds;

            foreach(bi, b; glSet.bindings) {

                foreach (di, d; b.descriptors) {

                    switch (b.layout.descriptorType) {
                    case DescriptorType.uniformBuffer:
                        _cmds ~= new BindUniformBufferCmd(
                            b.layout.binding, d.bufferRange, 0
                        );
                        break;
                    case DescriptorType.uniformBufferDynamic:
                        _cmds ~= new BindUniformBufferCmd(
                            b.layout.binding, d.bufferRange, dynamicOffsets[dynInd++]
                        );
                        break;
                    case DescriptorType.combinedImageSampler:
                        _cmds ~= new BindSamplerImageCmd(
                            b.layout.binding, d.combinedImageSampler
                        );
                        break;
                    default:
                        gfxGlLog.warning("unhandled descriptor set");
                        break;
                    }
                }
            }
        }
    }

    override void pushConstants(PipelineLayout layout, ShaderStage stages,
                                size_t offset, size_t size, const(void)* data)
    {
        gfxGlLog.warning("unimplemented GL command");
    }

    override void draw(uint vertexCount, uint instanceCount, uint firstVertex,
                       uint firstInstance)
    {
        ensureBindings();
        _cmds ~= new DrawCmd(
            _primitive, cast(GLint)firstVertex, cast(GLsizei)vertexCount,
            cast(GLsizei)instanceCount, cast(GLuint)firstInstance
        );
    }

    override void drawIndexed(uint indexCount, uint instanceCount,
                              uint firstVertex, int vertexOffset,
                              uint firstInstance)
    {
        ensureBindings();

        const factor = _indexType == GL_UNSIGNED_SHORT ? 2 : 4;
        const offset = factor * firstVertex + _indexOffset;

        _cmds ~= new DrawIndexedCmd(
            _primitive, cast(GLsizei)indexCount, _indexType, offset, cast(GLint)vertexOffset,
            cast(GLsizei)instanceCount, cast(GLuint)firstInstance
        );
    }

    private void dirty(Dirty flag) {
        _dirty |= flag;
    }

    private void clean(Dirty flag) {
        _dirty &= ~flag;
    }

    private bool allDirty(Dirty flags) {
        return (_dirty & flags) == flags;
    }

    private bool someDirty(Dirty flags) {
        return (_dirty & flags) != Dirty.none;
    }

    private void ensureBindings() {
        if (someDirty(Dirty.vertexBindings)) {
            bindAttribs();
            clean(Dirty.vertexBindings);
        }
    }

    private void bindAttribs() {
        assert(_vertexBindings.length == _inputBindings.length);
        assert(someDirty(Dirty.vertexBindings));

        import gfx.gl3.conv : glVertexFormat, vertexFormatSupported;
        import gfx.gl3.resource : GlBuffer;
        import gfx.graal.format : formatDesc;
        import std.algorithm : filter;

        foreach (bi, vb; _vertexBindings) {
            const bindingInfo = _inputBindings[bi];

            GlVertexAttrib[] attribs;

            foreach (ai; _inputAttribs.filter!(ia => ia.binding == bi)) {
                const f = ai.format;
                assert(vertexFormatSupported(f));

                attribs ~= GlVertexAttrib(
                    ai.location, glVertexFormat(f), vb.offset+ai.offset
                );
            }

            auto buf = cast(GlBuffer)vb.buffer;
            _cmds ~= new BindVertexBufCmd(buf.name, cast(GLsizei)bindingInfo.stride, attribs);
        }
    }

    void setActiveSubpass(uint subpass) {
        assert(_renderPass);
        assert(_attachments.length == _renderPass.attachments.length);
        const sp = _renderPass.subpasses[subpass];
        foreach (ref a; _attachments) {
            a.enabled = false;
        }
        foreach (ar; sp.colors) {
            _attachments[ar.attachment].enabled = true;
        }
        _subpass = subpass;
    }

}

private:

struct GlState {
    import gfx.graal.pipeline : DepthInfo, Rasterizer, StencilInfo, ViewportConfig;
    import gfx.graal.types : Rect, Viewport;

    GLuint prog;
    const(ViewportConfig)[] vcs;
    const(Viewport)[] viewports;
    const(Rect)[] scissors;
    Rasterizer rasterizer;
    DepthInfo depthInfo;
    StencilInfo stencilInfo;
}

struct GlColorAttachment {
    import gfx.graal.pipeline : ColorBlendAttachment;
    import gfx.graal.renderpass : AttachmentDescription;

    bool enabled;
    AttachmentDescription desc;
    ColorBlendAttachment attachment;
}

abstract class GlCommand {
    abstract void execute(GlQueue queue, Gl gl);
}

string allFieldsCtor(T)()
{
    import std.array : join;
    import std.traits : FieldNameTuple, Fields;

    alias names = FieldNameTuple!T;
    alias types = Fields!T;

    string[] fields;
    static foreach (i, n; names) {
        fields ~= types[i].stringof ~ " " ~ n;
    }
    string code = "this(" ~ fields.join(", ") ~ ") {\n";
    static foreach (n; names) {
        code ~= "    this." ~ n ~ " = " ~ n ~ ";\n";
    }
    return code ~ "}";
}

final class CopyBufToBufCmd : GlCommand
{
    import gfx.gl3.resource : GlBuffer;

    GlBuffer src;
    GlBuffer dst;
    CopyRegion region;

    mixin(allFieldsCtor!(typeof(this)));

    override void execute(GlQueue queue, Gl gl) {
        gl.BindBuffer(GL_COPY_READ_BUFFER, src.name);
        gl.BindBuffer(GL_COPY_WRITE_BUFFER, dst.name);
        gl.CopyBufferSubData(
            GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER,
            cast(GLintptr)region.offset.from, cast(GLintptr)region.offset.to,
            cast(GLsizeiptr)region.size
        );
        gl.BindBuffer(GL_COPY_READ_BUFFER, 0);
        gl.BindBuffer(GL_COPY_WRITE_BUFFER, 0);

        import gfx.gl3.error : glCheck;
        glCheck(gl, "copy buffer to buffer");
    }
}

final class CopyBufToImgCmd : GlCommand
{
    import gfx.gl3.resource : GlBuffer, GlImage;

    GlBuffer buf;
    GlImage img;
    BufferImageCopy region;

    mixin(allFieldsCtor!(typeof(this)));

    override void execute(GlQueue queue, Gl gl) {
        gl.ActiveTexture(GL_TEXTURE0);
        gl.BindBuffer(GL_PIXEL_UNPACK_BUFFER, buf.name);
        gl.BindTexture(img.texTarget, img.name);
        img.texSubImage(region);
        gl.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);

        import gfx.gl3.error : glCheck;
        glCheck(gl, "copy buffer to image");
    }
}

final class BindFramebufferCmd : GlCommand
{
    GLuint fbo;
    this(GLuint fbo) { this.fbo = fbo; }
    override void execute(GlQueue queue, Gl gl) {
        gl.BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
    }
}

final class SetupFramebufferCmd : GlCommand
{
    import gfx.gl3.resource : GlImage, GlImgType;

    GLuint fbo;
    GlImage img;

    this(GLuint fbo, GlImage img) {
        this.fbo = fbo;
        this.img = img;
    }

    override void execute(GlQueue queue, Gl gl) {
        gl.BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
        final switch (img.glType) {
        case GlImgType.renderBuf:
            gl.FramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, img.name);
            break;
        case GlImgType.tex:
            gl.FramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, img.name, 0);
            break;
        }
        const GLenum drawBuf = GL_COLOR_ATTACHMENT0;
        gl.DrawBuffers(1, &drawBuf);
    }
}

final class SetViewportConfigsCmd : GlCommand
{
    import gfx.graal.pipeline : ViewportConfig;
    ViewportConfig[] viewports;
    this (ViewportConfig[] viewports) {
        this.viewports = viewports;
    }

    override void execute(GlQueue queue, Gl gl) {

        if (queue.state.vcs == viewports) return;

        if (viewports.length > 1 && !queue.info.viewportArray) {
            gfxGlLog.error("ARB_viewport_array not supported");
            viewports = viewports[0..1];
        }

        if (viewports.length > 1) {
            foreach (i, vc; viewports) {
                const vp = vc.viewport;
                gl.ViewportIndexedf(cast(GLuint)i, vp.x, vp.y, vp.width, vp.height);
                gl.DepthRangeIndexed(cast(GLuint)i, vp.minDepth, vp.maxDepth);

                const sc = vc.scissors;
                gl.ScissorIndexed(
                    cast(GLuint)i,
                    cast(GLint)sc.x, cast(GLint)sc.y,
                    cast(GLsizei)sc.width, cast(GLsizei)sc.height
                );
            }
        }
        else if (viewports.length == 1) {
            const vp = viewports[0].viewport;
            gl.Viewport(
                cast(GLint)vp.x, cast(GLint)vp.y,
                cast(GLsizei)vp.width, cast(GLsizei)vp.height
            );
            gl.DepthRangef(vp.minDepth, vp.maxDepth);

            const sc = viewports[0].scissors;
            gl.Scissor(
                cast(GLint)sc.x, cast(GLint)sc.y,
                cast(GLsizei)sc.width, cast(GLsizei)sc.height
            );
        }

        queue.state.vcs = viewports;
    }
}

final class SetViewportsCmd : GlCommand
{
    import gfx.graal.types : Viewport;

    uint firstViewport;
    const(Viewport)[] viewports;

    this (in uint firstViewport, const(Viewport)[] viewports) {
        this.firstViewport = firstViewport;
        this.viewports = viewports;
    }

    override void execute(GlQueue queue, Gl gl) {

        if (queue.state.viewports == viewports) return;

        bool useArray = viewports.length > 1 || firstViewport > 0;

        if (useArray && !queue.info.viewportArray) {
            gfxGlLog.error("ARB_viewport_array not supported");
            viewports = viewports[0..1];
            firstViewport = 0;
            useArray = false;
        }

        if (useArray) {
            foreach (i, vp; viewports) {
                gl.ViewportIndexedf(cast(GLuint)(i+firstViewport), vp.x, vp.y, vp.width, vp.height);
                gl.DepthRangeIndexed(cast(GLuint)(i+firstViewport), vp.minDepth, vp.maxDepth);
            }
        }
        else if (viewports.length == 1) {
            const vp = viewports[0];
            gl.Viewport(
                cast(GLint)vp.x, cast(GLint)vp.y,
                cast(GLsizei)vp.width, cast(GLsizei)vp.height
            );
            gl.DepthRangef(vp.minDepth, vp.maxDepth);
        }

        queue.state.viewports = viewports;
    }
}

final class SetScissorsCmd : GlCommand
{
    import gfx.graal.types : Rect;

    uint firstScissor;
    const(Rect)[] scissors;

    this (in uint firstScissor, const(Rect)[] scissors) {
        this.firstScissor = firstScissor;
        this.scissors = scissors;
    }

    override void execute(GlQueue queue, Gl gl)
    {
        import std.algorithm : equal, map;

        if (queue.state.scissors == scissors) return;

        bool useArray = scissors.length > 1 || firstScissor > 0;
        if (useArray && !queue.info.viewportArray) {
            gfxGlLog.error("ARB_viewport_array not supported");
            scissors = scissors[0..1];
            firstScissor = 0;
            useArray = false;
        }

        if (useArray) {
            foreach (i, sc; scissors) {
                gl.ScissorIndexed(
                    cast(GLuint)(i+firstScissor),
                    cast(GLint)sc.x, cast(GLint)sc.y,
                    cast(GLsizei)sc.width, cast(GLsizei)sc.height
                );
            }
        }
        else if (scissors.length == 1) {
            const sc = scissors[0];
            gl.Scissor(
                cast(GLint)sc.x, cast(GLint)sc.y,
                cast(GLsizei)sc.width, cast(GLsizei)sc.height
            );
        }

        queue.state.scissors = scissors;
    }
}

final class SetLineWidthCmd : GlCommand
{
    float lineWidth;
    this (in float lineWidth) {
        this.lineWidth = lineWidth;
    }
    override void execute(GlQueue queue, Gl gl) {
        gl.LineWidth(this.lineWidth);
    }
}

final class SetDepthBiasCmd : GlCommand
{
    float constFactor;
    float clamp;
    float slopeFactor;

    mixin(allFieldsCtor!(typeof(this)));

    override void execute(GlQueue queue, Gl gl)
    {
        if (queue.info.polygonOffsetClamp) {
            gl.PolygonOffsetClamp(slopeFactor, constFactor, clamp);
        }
        else {
            gl.PolygonOffset(slopeFactor, constFactor);
        }
    }
}

final class SetBlendConstantsCmd : GlCommand
{
    float[4] constants;

    mixin(allFieldsCtor!(typeof(this)));

    override void execute(GlQueue queue, Gl gl)
    {
        gl.BlendColor(constants[0], constants[1], constants[2], constants[3]);
    }
}

final class ClearColorCmd : GlCommand {

    ClearColorValues values;

    this (ClearColorValues values) {
        this.values = values;
    }

    override void execute(GlQueue queue, Gl gl) {
        gl.ColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        final switch (values.type) {
        case ClearColorValues.Type.f32:
            gl.ClearBufferfv(GL_COLOR, 0, &values.values.f32[0]);
            break;
        case ClearColorValues.Type.i32:
            gl.ClearBufferiv(GL_COLOR, 0, &values.values.i32[0]);
            break;
        case ClearColorValues.Type.u32:
            gl.ClearBufferuiv(GL_COLOR, 0, &values.values.u32[0]);
            break;
        }
    }
}

final class ClearDepthStencilCmd : GlCommand {

    ClearDepthStencilValues values;
    bool depth;
    bool stencil;

    this (ClearDepthStencilValues values, bool depth, bool stencil) {
        this.values = values;
        this.depth = depth;
        this.stencil = stencil;
    }

    override void execute(GlQueue queue, Gl gl) {
        if (depth) {
            gl.DepthMask(GL_TRUE);
            gl.ClearBufferfv(GL_DEPTH, 0, &values.depth);
        }
        if (stencil) {
            const val = cast(GLint)values.stencil;
            gl.StencilMask(GLuint.max);
            gl.ClearBufferiv(GL_STENCIL, 0, &val);
        }
    }
}

final class BindProgramCmd : GlCommand
{
    GLuint prog;
    this(GLuint prog) { this.prog = prog; }
    override void execute(GlQueue queue, Gl gl) {
        if (queue.state.prog == prog) return;
        gl.UseProgram(prog);
        queue.state.prog = prog;
    }
}

final class SetRasterizerCmd : GlCommand
{
    import gfx.graal.pipeline : Rasterizer;
    Rasterizer rasterizer;
    this(Rasterizer rasterizer) { this.rasterizer = rasterizer; }

    override void execute(GlQueue queue, Gl gl) {
        import gfx.gl3.conv : toGl;
        import gfx.graal.pipeline : Cull, PolygonMode;

        if (queue.state.rasterizer == rasterizer) return;

        void polygonBias(GLenum polygonMode, GLenum depthBias)
        {
            gl.PolygonMode(GL_FRONT_AND_BACK, polygonMode);
            if (rasterizer.depthBias.isSome) {
                const db = rasterizer.depthBias.get;
                gl.Enable(depthBias);
                if (queue.info.polygonOffsetClamp) {
                    gl.PolygonOffsetClamp(db.slopeFactor, db.constantFactor, db.clamp);
                }
                else {
                    gl.PolygonOffset(db.slopeFactor, db.constantFactor);
                }
            }
            else {
                gl.Disable(depthBias);
            }
        }

        final switch (rasterizer.mode) {
        case PolygonMode.point:
            polygonBias(GL_POINT, GL_POLYGON_OFFSET_POINT);
            break;
        case PolygonMode.line:
            polygonBias(GL_LINE, GL_POLYGON_OFFSET_LINE);
            gl.LineWidth(rasterizer.lineWidth);
            break;
        case PolygonMode.fill:
            polygonBias(GL_FILL, GL_POLYGON_OFFSET_FILL);
            break;
        }

        if (rasterizer.cull == Cull.none) {
            gl.Disable(GL_CULL_FACE);
        }
        else {
            gl.Enable(GL_CULL_FACE);
            switch (rasterizer.cull) {
            case Cull.back:
                gl.CullFace(GL_BACK);
                break;
            case Cull.front:
                gl.CullFace(GL_FRONT);
                break;
            case Cull.frontAndBack:
                gl.CullFace(GL_FRONT_AND_BACK);
                break;
            default: break;
            }
            gl.FrontFace(toGl(rasterizer.front));
        }

        if (rasterizer.depthClamp) {
            gl.Enable(GL_DEPTH_CLAMP);
        }
        else {
            gl.Disable(GL_DEPTH_CLAMP);
        }

        queue.state.rasterizer = rasterizer;
    }
}

final class SetDepthInfoCmd : GlCommand
{
    import gfx.graal.pipeline : DepthInfo;

    DepthInfo info;
    this (DepthInfo info) { this.info = info; }

    override void execute(GlQueue queue, Gl gl) {
        import gfx.gl3.conv : toGl;

        if (queue.state.depthInfo == info) return;

        if (info.enabled) {
            gl.Enable(GL_DEPTH_TEST);
            gl.DepthFunc(toGl(info.compareOp));
            gl.DepthMask(cast(GLboolean)info.write);
            if (info.boundsTest) {
                gfxGlLog.warning("no support for depth bounds test");
            }
        }
        else {
            gl.Disable(GL_DEPTH_TEST);
        }

        queue.state.depthInfo = info;
    }
}

final class SetStencilInfoCmd : GlCommand
{
    import gfx.graal.pipeline : StencilInfo;

    StencilInfo info;
    this(StencilInfo info) { this.info = info; }

    override void execute(GlQueue queue, Gl gl) {
        import gfx.gl3.conv : toGl;
        import gfx.graal.pipeline : StencilOpState;

        if (queue.state.stencilInfo == info) return;

        if (info.enabled) {
            gl.Enable(GL_STENCIL_TEST);
            void bindFace(GLenum face, StencilOpState state) {
                gl.StencilOpSeparate(
                    face, toGl(state.failOp), toGl(state.depthFailOp), toGl(state.passOp)
                );
                gl.StencilFuncSeparate(
                    face, toGl(state.compareOp), state.refMask, state.compareMask
                );
                gl.StencilMaskSeparate(
                    face, state.writeMask
                );
            }
            bindFace(GL_FRONT, info.front);
            bindFace(GL_BACK, info.back);
        }
        else {
            gl.Disable(GL_STENCIL_TEST);
        }
    }
}

struct GlVertexAttrib {
    import gfx.gl3.conv : GlVertexFormat;

    GLuint index;
    GlVertexFormat format;
    size_t offset;
}

final class BindVertexBufCmd : GlCommand
{
    GLuint buffer;
    GLsizei stride;
    GlVertexAttrib[] attribs;

    this(GLuint buffer, GLsizei stride, GlVertexAttrib[] attribs) {
        this.buffer = buffer;
        this.stride = stride;
        this.attribs = attribs;
    }

    override void execute(GlQueue queue, Gl gl)
    {
        import gfx.gl3.conv : VAOAttribFun;

        gl.BindBuffer(GL_ARRAY_BUFFER, buffer);
        foreach(at; attribs) {
            final switch (at.format.fun) {
            case VAOAttribFun.f:
                gl.VertexAttribPointer(
                    at.index, at.format.size, at.format.type,
                    at.format.normalized, stride, cast(const(void*))at.offset
                );
                break;
            case VAOAttribFun.i:
                gl.VertexAttribIPointer(
                    at.index, at.format.size, at.format.type, stride,
                    cast(const(void*))at.offset
                );
                break;
            case VAOAttribFun.d:
                gl.VertexAttribLPointer(
                    at.index, at.format.size, at.format.type, stride,
                    cast(const(void*))at.offset
                );
                break;
            }
            gl.EnableVertexAttribArray(at.index);
        }
        gl.BindBuffer(GL_ARRAY_BUFFER, 0);
    }
}

final class BindIndexBufCmd : GlCommand
{
    GLuint buf;

    this(GLuint buf) {
        this.buf = buf;
    }

    override void execute(GlQueue queue, Gl gl)
    {
        gl.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf);
    }
}

final class BindUniformBufferCmd : GlCommand
{
    import gfx.gl3.resource : GlBuffer;
    import gfx.graal.pipeline : BufferRange;

    GLuint binding;
    BufferRange bufferRange;
    size_t dynamicOffset;

    this (GLuint binding, BufferRange br, in size_t dynOffset) {
        this.binding = binding;
        this.bufferRange = br;
        this.dynamicOffset = dynOffset;
    }

    override void execute(GlQueue queue, Gl gl) {
        auto glBuf = cast(GlBuffer)bufferRange.buffer;

        gl.BindBufferRange(
            GL_UNIFORM_BUFFER, binding, glBuf.name,
            cast(GLintptr)(bufferRange.offset+dynamicOffset),
            cast(GLintptr)bufferRange.range
        );
    }
}

final class BindSamplerImageCmd : GlCommand
{
    import gfx.graal.pipeline : CombinedImageSampler;

    GLuint binding;
    CombinedImageSampler cis;

    mixin(allFieldsCtor!(typeof(this)));

    override void execute(GlQueue queue, Gl gl)
    {
        import gfx.gl3.conv : toGl;
        import gfx.gl3.error : glCheck;
        import gfx.gl3.resource : GlImageView, GlSampler;

        auto view = cast(GlImageView)cis.view;
        auto sampler = cast(GlSampler)cis.sampler;

        gl.ActiveTexture(GL_TEXTURE0 + binding);
        gl.BindTexture(view.target, view.name);
        glCheck(gl, "bind texture");

        sampler.bind(view.target, binding);
        glCheck(gl, "bind sampler");

        const swizzle = toGl(view.swizzle);
        gl.TexParameteriv(view.target, GL_TEXTURE_SWIZZLE_RGBA, &swizzle[0]);
    }
}

final class BindBlendSlotsCmd : GlCommand
{
    import gfx.graal.pipeline : ColorMask;

    GlColorAttachment[] attachments;

    this(GlColorAttachment[] attachments) {
        this.attachments = attachments;
    }

    override void execute(GlQueue queue, Gl gl)
    {
        import gfx.gl3.conv : toGl;

        foreach (GLuint slot, a; attachments) {
            if (a.enabled) {
                // TODO logicOp
                if (a.attachment.enabled) {
                    // TODO
                    gl.Enablei(GL_BLEND, slot);
                    gl.BlendEquationSeparatei(slot,
                        toGl(a.attachment.colorBlend.op),
                        toGl(a.attachment.alphaBlend.op),
                    );
                    gl.BlendFuncSeparatei(slot,
                        toGl(a.attachment.colorBlend.factor.from),
                        toGl(a.attachment.colorBlend.factor.to),
                        toGl(a.attachment.alphaBlend.factor.from),
                        toGl(a.attachment.alphaBlend.factor.to),
                    );
                }
                else {
                    gl.Disablei(GL_BLEND, slot);
                }
                import std.typecons : BitFlags, Yes;
                BitFlags!(ColorMask, Yes.unsafe) cm = a.attachment.colorMask;
                gl.ColorMaski(
                    slot,
                    (cm & ColorMask.r) ? GL_TRUE : GL_FALSE,
                    (cm & ColorMask.g) ? GL_TRUE : GL_FALSE,
                    (cm & ColorMask.b) ? GL_TRUE : GL_FALSE,
                    (cm & ColorMask.a) ? GL_TRUE : GL_FALSE
                );
            }
            else {
                gl.ColorMaski(
                    slot, GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE
                );
            }
        }
    }
}

final class DrawCmd : GlCommand
{
    GLenum primitive;
    GLint first;
    GLsizei count;
    GLsizei instanceCount;
    GLuint baseInstance;

    this (GLenum primitive, GLint first, GLsizei count, GLsizei instanceCount,
            GLuint baseInstance)
    {
        this.primitive = primitive;
        this.first = first;
        this.count = count;
        this.instanceCount = instanceCount;
        this.baseInstance = baseInstance;
    }

    override void execute(GlQueue queue, Gl gl) {
        if (baseInstance != 0 && !queue.info.baseInstance) {
            gfxGlLog.error("No support for ARB_base_instance");
            return;
        }
        if (instanceCount <= 1) {
            gl.DrawArrays(primitive, first, count);
        }
        else if (instanceCount > 1 && baseInstance == 0) {
            gl.DrawArraysInstanced(primitive, first, count, instanceCount);
        }
        else if (instanceCount > 1 && baseInstance != 0) {
            gl.DrawArraysInstancedBaseInstance(
                primitive, first, count, instanceCount, baseInstance
            );
        }
        import gfx.gl3.error : glCheck;
        glCheck(gl, "draw");
    }
}

final class DrawIndexedCmd : GlCommand
{
    GLenum primitive;
    GLsizei count;
    GLenum type;
    size_t indexBufOffset;
    GLint baseVertex;
    GLsizei instanceCount;
    GLuint baseInstance;

    this(GLenum primitive, GLsizei count, GLenum type, size_t indexBufOffset,
            GLint baseVertex, GLsizei instanceCount, GLuint baseInstance)
    {
        this.primitive = primitive;
        this.count = count;
        this.type = type;
        this.indexBufOffset = indexBufOffset;
        this.baseVertex = baseVertex;
        this.instanceCount = instanceCount;
        this.baseInstance = baseInstance;
    }

    override void execute(GlQueue queue, Gl gl)
    {
        const offset = cast(const(void*))indexBufOffset;

        if (baseVertex != 0 && !queue.info.drawElementsBaseVertex) {
            gfxGlLog.error("No support for ARB_draw_elements_base_vertex");
            return;
        }
        if (baseInstance != 0 && !queue.info.baseInstance) {
            gfxGlLog.error("No support for ARB_base_instance");
            return;
        }

        if (instanceCount <= 1 && baseVertex == 0) {
            gl.DrawElements(primitive, count, type, offset);
        }
        else if (instanceCount <= 1 && baseVertex != 0) {
            gl.DrawElementsBaseVertex(primitive, count, type, offset, baseVertex);
        }
        else if (instanceCount > 1 && baseInstance == 0 && baseVertex == 0) {
            gl.DrawElementsInstanced(primitive, count, type, offset, instanceCount);
        }
        else if (instanceCount > 1 && baseInstance == 0 && baseVertex != 0) {
            gl.DrawElementsInstancedBaseVertex(
                primitive, count, type, offset, instanceCount, baseVertex
            );
        }
        else if (instanceCount > 1 && baseInstance != 0 && baseVertex == 0) {
            gl.DrawElementsInstancedBaseInstance(
                primitive, count, type, offset, instanceCount, baseInstance
            );
        }
        else {
            gl.DrawElementsInstancedBaseVertexBaseInstance(
                primitive, count, type, offset, instanceCount, baseVertex, baseInstance
            );
        }
        import gfx.gl3.error : glCheck;
        glCheck(gl, "draw indexed");
    }
}