Commands.h

Go to the documentation of this file.

// Copyright (c) 2018 the Talvos developers. All rights reserved.
//
// This file is distributed under a three-clause BSD license. For full license
// terms please see the LICENSE file distributed with this source code.


#ifndef TALVOS_COMMANDS_H
#define TALVOS_COMMANDS_H

#include <memory>
#include <vector>

#include "vulkan/vulkan_core.h"

#include "talvos/Dim3.h"
#include "talvos/PipelineContext.h"

namespace talvos
{

class Device;
class ComputePipeline;
class GraphicsPipeline;
class Image;
class Object;
class RenderPassInstance;

class Command
{
public:
  enum Type
  {
    BEGIN_RENDER_PASS,
    BLIT_IMAGE,
    CLEAR_ATTACHMENT,
    CLEAR_COLOR_IMAGE,
    COPY_BUFFER,
    COPY_BUFFER_TO_IMAGE,
    COPY_IMAGE,
    COPY_IMAGE_TO_BUFFER,
    DISPATCH,
    DRAW,
    DRAW_INDEXED,
    END_RENDER_PASS,
    FILL_BUFFER,
    NEXT_SUBPASS,
    SET_EVENT,
    RESET_EVENT,
    UPDATE_BUFFER,
    WAIT_EVENTS,
  };

  Type getType() const { return Ty; }

  void run(Device &Dev) const;

protected:
  Command(Type Ty) : Ty(Ty){};

  Type Ty; 

  virtual void runImpl(Device &Dev) const = 0;
};

class BeginRenderPassCommand : public Command
{
public:
  BeginRenderPassCommand(std::shared_ptr<RenderPassInstance> RPI)
      : Command(BEGIN_RENDER_PASS), RPI(RPI)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  std::shared_ptr<RenderPassInstance> RPI;
};

class BlitImageCommand : public Command
{
public:
  BlitImageCommand(const Image &SrcImage, const Image &DstImage,
                   const std::vector<VkImageBlit> &Regions, VkFilter Filter)
      : Command(BLIT_IMAGE), SrcImage(SrcImage), DstImage(DstImage),
        Regions(Regions), Filter(Filter)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  const Image &SrcImage;

  const Image &DstImage;

  std::vector<VkImageBlit> Regions;

  VkFilter Filter;
};

class ClearAttachmentCommand : public Command
{
public:
  ClearAttachmentCommand(const RenderPassInstance &RPI,
                         const std::vector<VkClearAttachment> &ClearAttachments,
                         const std::vector<VkClearRect> &ClearRects)
      : Command(CLEAR_ATTACHMENT), RPI(RPI), ClearAttachments(ClearAttachments),
        ClearRects(ClearRects)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  const RenderPassInstance &RPI;

  std::vector<VkClearAttachment> ClearAttachments;

  std::vector<VkClearRect> ClearRects;
};

class ClearColorImageCommand : public Command
{
public:
  ClearColorImageCommand(const Image &DstImage, VkClearColorValue Color,
                         const std::vector<VkImageSubresourceRange> &Ranges)
      : Command(CLEAR_COLOR_IMAGE), DstImage(DstImage), Color(Color),
        Ranges(Ranges)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  const Image &DstImage;

  VkClearColorValue Color;

  std::vector<VkImageSubresourceRange> Ranges;
};

class CopyBufferCommand : public Command
{
public:
  CopyBufferCommand(uint64_t SrcAddr, uint64_t DstAddr,
                    const std::vector<VkBufferCopy> &Regions)
      : Command(COPY_BUFFER), SrcAddr(SrcAddr), DstAddr(DstAddr),
        Regions(Regions)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  uint64_t SrcAddr;

  uint64_t DstAddr;

  std::vector<VkBufferCopy> Regions;
};

class CopyBufferToImageCommand : public Command
{
public:
  CopyBufferToImageCommand(uint64_t SrcAddr, const Image &DstImage,
                           const std::vector<VkBufferImageCopy> &Regions)
      : Command(COPY_BUFFER_TO_IMAGE), SrcAddr(SrcAddr), DstImage(DstImage),
        Regions(Regions)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  uint64_t SrcAddr;

  const Image &DstImage;

  std::vector<VkBufferImageCopy> Regions;
};

class CopyImageCommand : public Command
{
public:
  CopyImageCommand(const Image &SrcImage, const Image &DstImage,
                   const std::vector<VkImageCopy> &Regions)
      : Command(COPY_IMAGE), SrcImage(SrcImage), DstImage(DstImage),
        Regions(Regions)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  const Image &SrcImage;

  const Image &DstImage;

  std::vector<VkImageCopy> Regions;
};

class CopyImageToBufferCommand : public Command
{
public:
  CopyImageToBufferCommand(const Image &SrcImage, uint64_t DstAddr,
                           const std::vector<VkBufferImageCopy> &Regions)
      : Command(COPY_IMAGE_TO_BUFFER), SrcImage(SrcImage), DstAddr(DstAddr),
        Regions(Regions)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  const Image &SrcImage;

  uint64_t DstAddr;

  std::vector<VkBufferImageCopy> Regions;
};

class DispatchCommand : public Command
{
public:
  DispatchCommand(const PipelineContext &PC, Dim3 BaseGroup, Dim3 NumGroups)
      : Command(DISPATCH), PC(PC), BaseGroup(BaseGroup), NumGroups(NumGroups)
  {}

  Dim3 getBaseGroup() const { return BaseGroup; }

  Dim3 getNumGroups() const { return NumGroups; }

  const PipelineContext &getPipelineContext() const { return PC; }

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  PipelineContext PC; 

  Dim3 BaseGroup; 
  Dim3 NumGroups; 
};

class DrawCommandBase : public Command
{
public:
  DrawCommandBase(Type Ty, const PipelineContext &PC,
                  const std::shared_ptr<RenderPassInstance> RPI,
                  uint32_t NumVertices, uint32_t VertexOffset,
                  uint32_t NumInstances, uint32_t InstanceOffset)
      : Command(Ty), PC(PC), RPI(RPI), NumVertices(NumVertices),
        VertexOffset(VertexOffset), NumInstances(NumInstances),
        InstanceOffset(InstanceOffset)
  {}

  uint32_t getInstanceOffset() const { return InstanceOffset; }

  uint32_t getNumInstances() const { return NumInstances; }

  uint32_t getNumVertices() const { return NumVertices; }

  const PipelineContext &getPipelineContext() const { return PC; }

  const RenderPassInstance &getRenderPassInstance() const { return *RPI; }

  uint32_t getVertexOffset() const { return VertexOffset; }

  void setRenderPassInstance(const std::shared_ptr<RenderPassInstance> RPI)
  {
    this->RPI = RPI;
  }

protected:
  virtual void runImpl(Device &Dev) const override = 0;

private:
  PipelineContext PC; 

  std::shared_ptr<RenderPassInstance> RPI; 

  uint32_t NumVertices;    
  uint32_t VertexOffset;   
  uint32_t NumInstances;   
  uint32_t InstanceOffset; 
};

class DrawCommand : public DrawCommandBase
{
public:
  DrawCommand(const PipelineContext &PC,
              const std::shared_ptr<RenderPassInstance> RPI,
              uint32_t NumVertices, uint32_t VertexOffset,
              uint32_t NumInstances, uint32_t InstanceOffset)
      : DrawCommandBase(DRAW, PC, RPI, NumVertices, VertexOffset, NumInstances,
                        InstanceOffset){};

protected:
  virtual void runImpl(Device &Dev) const override;
};

class DrawIndexedCommand : public DrawCommandBase
{
public:
  DrawIndexedCommand(const PipelineContext &PC,
                     const std::shared_ptr<RenderPassInstance> RPI,
                     uint32_t NumVertices, uint32_t IndexOffset,
                     uint32_t VertexOffset, uint32_t NumInstances,
                     uint32_t InstanceOffset, uint64_t IndexBaseAddress,
                     VkIndexType IndexType)
      : DrawCommandBase(DRAW_INDEXED, PC, RPI, NumVertices, VertexOffset,
                        NumInstances, InstanceOffset),
        IndexOffset(IndexOffset), IndexBaseAddress(IndexBaseAddress),
        IndexType(IndexType){};

  uint64_t getIndexBaseAddress() const { return IndexBaseAddress; }

  uint32_t getIndexOffset() const { return IndexOffset; }

  VkIndexType getIndexType() const { return IndexType; }

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  uint32_t IndexOffset;      
  uint64_t IndexBaseAddress; 
  VkIndexType IndexType;     
};

class EndRenderPassCommand : public Command
{
public:
  EndRenderPassCommand(std::shared_ptr<RenderPassInstance> RPI)
      : Command(END_RENDER_PASS), RPI(RPI)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  std::shared_ptr<RenderPassInstance> RPI;
};

class FillBufferCommand : public Command
{
public:
  FillBufferCommand(uint64_t Base, uint64_t NumBytes, uint32_t Data)
      : Command(FILL_BUFFER), Base(Base), NumBytes(NumBytes), Data(Data)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  uint64_t Base;

  uint64_t NumBytes;

  uint32_t Data;
};

class NextSubpassCommand : public Command
{
public:
  NextSubpassCommand(std::shared_ptr<RenderPassInstance> RPI)
      : Command(NEXT_SUBPASS), RPI(RPI)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  std::shared_ptr<RenderPassInstance> RPI;
};

class ResetEventCommand : public Command
{
public:
  ResetEventCommand(volatile bool *Event) : Command(RESET_EVENT), Event(Event)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  volatile bool *Event;
};

class SetEventCommand : public Command
{
public:
  SetEventCommand(volatile bool *Event) : Command(SET_EVENT), Event(Event) {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  volatile bool *Event;
};

class UpdateBufferCommand : public Command
{
public:
  UpdateBufferCommand(uint64_t Base, uint64_t NumBytes, const void *Data);

  ~UpdateBufferCommand();

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  uint64_t Base;

  uint64_t NumBytes;

  uint8_t *Data;
};

class WaitEventsCommand : public Command
{
public:
  WaitEventsCommand(std::vector<volatile bool *> Events)
      : Command(WAIT_EVENTS), Events(Events)
  {}

protected:
  virtual void runImpl(Device &Dev) const override;

private:
  std::vector<volatile bool *> Events;
};

} // namespace talvos

#endif