RenderList.h

#pragma once
 
#include "Resources/MaterialInstance.h"
 
#include "IRenderer.h"
#include "RenderMesh.h"
#include "RenderStates.h"
#include "RenderResource.h"
#include "../Components/Core/RenderComponent.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  struct RenderTaskContext;
 
  enum struct RenderItemFlags : uint16_t
  {
    None            = 0,
    Custom          = 1 << 0,
    CastShadows     = 1 << 1,
    CalculateDepth  = 1 << 2,
    Sprite          = 1 << 3,
    AlwaysOnTop     = 1 << 4,
    Clockwise       = 1 << 5,
    Transparent     = 1 << 6,
    Backdrop        = 1 << 7,
    CustomBucket    = 1 << 8,
    CustomBounds    = 1 << 9,
    Custom2         = 1 << 10,
    DisableCulling  = 1 << 11,
    Instanced       = 1 << 12,
    ObjectBufferSlot = 1 << 13
  };
  ENABLE_ENUM_FLAGS(RenderItemFlags);
 
  enum struct StateChangeFlags : uint16_t {
    ChangeNone              = 0,
    ChangeTransform         = 1 << 0,
    ChangeMesh              = 1 << 1,
    ChangeMaterialInstance  = 1 << 2,
    ChangeMaterialVariant   = 1 << 3,
    ChangeRasterizerState   = 1 << 4,
    ChangeBlendState        = 1 << 5,
    ChangeDepthStencilState = 1 << 6,
    ChangeLayer             = 1 << 7,
    ChangeViewport          = 1 << 8,
    ChangeViewportData      = 1 << 9,
    ChangeAll               = 0xFFFF
  };
  ENABLE_ENUM_FLAGS(StateChangeFlags);
 
  enum struct BucketType
  {
    Backdrop = 0,       
    SolidOrderedBack,   
    Solid,              
    SolidOrderedFront,  
    Transparent,        
    Annotation,
    Overlay,
    Custom,
    Count
  };
 
  enum class BucketMask
  {
    BackDrop    = 1 << size_t(BucketType::Backdrop),
    Transparent = 1 << size_t(BucketType::Transparent),
    Solid       = (1 << size_t(BucketType::SolidOrderedBack)) | (1 << size_t(BucketType::Solid)) | (1 << size_t(BucketType::SolidOrderedFront)),
    Opaque      = Solid,
    Annotation = 1 << size_t(BucketType::Annotation),
    Overlay     = 1 << size_t(BucketType::Overlay),
    Custom      = 1 << size_t(BucketType::Custom),
    All         = ~0,
    None        = 0,
  };
  ENABLE_ENUM_FLAGS(BucketMask);
 
  inline bool hasBucket(BucketMask bucketMask, BucketType bucket)
  {
    return (size_t(bucketMask) & (size_t(1) << size_t(bucket))) != 0;
  }
 
  struct RenderItem
  {
    typedef void CustomCallback(RenderTaskContext*, DrawContext*, const RenderItem*);
    typedef void CustomCallback2(RenderTaskContext*, DrawContext*, struct RenderListTask* task, const RenderItem*);
 
 
    bool isCustom() const { return (flags & (RenderItemFlags::Custom | RenderItemFlags::Custom2)) != 0; }
    bool isCustom1() const { return (flags & RenderItemFlags::Custom) != 0; }
    bool isCustom2() const { return (flags & RenderItemFlags::Custom2) != 0; }
    bool isSprite() const { return (flags & RenderItemFlags::Sprite) != 0; }
    bool isClockwise() const { return (flags & RenderItemFlags::Clockwise) != 0; }
    bool isTransparent() const { return (flags & RenderItemFlags::Transparent) != 0; }
    bool isCustomBucket() const { return (flags & RenderItemFlags::CustomBucket) != 0; }
    bool isBackdrop() const { return (flags & RenderItemFlags::Backdrop) != 0; }
    bool needsDepthCalculation() const { return (flags & RenderItemFlags::CalculateDepth) != 0; }
    bool hasBoundingBox() const { return (flags & RenderItemFlags::CustomBounds) != 0; }
    bool isCulled() const { return !hasBoundingBox() && !isCustom(); }
    bool isInstanced() const { return (flags & RenderItemFlags::Instanced) != 0; }
    bool hasObjectBufferSlot() const { return (flags & RenderItemFlags::ObjectBufferSlot) != 0; }
 
    void setBounds(const Geometry::BoundingBox* bounds)
    {
      boundingBox = bounds;
      flags |= RenderItemFlags::CustomBounds;
    }
 
    template<typename T>
    void setCallbackData(T* t) const { callbackData = t; }
 
    template<typename T>
    void setCallbackData2(T* t) const { callbackData2 = t; }
 
    template<typename T>
    T* getCallbackData() const { return static_cast<T*>(callbackData); }
 
    template<typename T>
    T* getCallbackData2() const { return static_cast<T*>(callbackData2); }
 
 
 
    const struct RenderMaterialInstance * renderMaterialInstance = nullptr;
    const MaterialInstance * materialInstance = nullptr;
 
    const struct EffectBinding * binding = nullptr;
    const struct CameraData * viewportData = nullptr;
    const struct PoseData * poseData = nullptr;
    union
    {
      uint32_t cullingIndex;
      const Geometry::BoundingBox* boundingBox = nullptr;
    };
 
    VertexArrayObjectHandle vertexArrayObject = VertexArrayObjectHandle::NoHandle;  // FIXME: input layout and vao is mutually exclusive
 
    union
    {
      struct
      {
        const glm::mat4* worldMatrix;
 
        const RenderMesh* meshData;
        uint32_t startIndex;
        uint32_t numIndexes;
 
        const RenderMesh* instanceData;
        uint32_t startInstance;
        uint32_t numInstances;
 
        Cogs::PrimitiveType primitiveType;
      };
 
      struct
      {
        const MeshStreamsLayout* streamsLayout;
        union
        {
          CustomCallback* callback;
          CustomCallback2* callback2;
        };
        mutable void* callbackData;
        mutable void* callbackData2;
      };
    };
 
    RenderComponent::LodData lod;
    RenderLayers layer = RenderLayers::None;                      
    float depth = 0.f;                                            
    int32_t drawOrder = 0;                                        
    union {
      uint32_t objectId = 0;                                        
      uint32_t objectBufferSlot;                                  
    };
    RenderItemFlags flags = RenderItemFlags::None;
    StateChangeFlags stateChanges = StateChangeFlags::ChangeAll;  
 
    // Pipeline state
    //
    // Note: These will all be merged into one state handle moving to PSO in future
    // graphics APIs.
    uint16_t blendState = 0;
    uint16_t depthState = 0;
    uint16_t rasterizerState = 0;
    uint8_t clipShapeIx = 0;
 
    size_t hash(size_t hashValue = Cogs::hash()) const {
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(renderMaterialInstance), hashValue);
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(materialInstance), hashValue);
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(binding), hashValue);
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(viewportData), hashValue);
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(poseData), hashValue);
 
      if (hasBoundingBox()) {
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(boundingBox), hashValue);
      }
      else {
        hashValue = Cogs::hash(cullingIndex, hashValue);
      }
      hashValue = Cogs::hash(vertexArrayObject.handle);
 
      if (isCustom()) {
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(worldMatrix), hashValue);
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(meshData), hashValue);
        hashValue = Cogs::hash(startIndex, hashValue);
        hashValue = Cogs::hash(numIndexes, hashValue);
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(instanceData), hashValue);
        hashValue = Cogs::hash(startInstance, hashValue);
        hashValue = Cogs::hash(numInstances, hashValue);
        hashValue = Cogs::hash(primitiveType, hashValue);
      }
      else {
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(streamsLayout), hashValue);
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(callback), hashValue);
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(callbackData), hashValue);
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(callbackData2), hashValue);
      }
 
      hashValue = Cogs::hash(lod.selectedLod, hashValue);
      hashValue = Cogs::hash(lod.numLods, hashValue);
      hashValue = Cogs::hash(lod.currentLod, hashValue);
      hashValue = Cogs::hash(lod.lodFraction, hashValue);
      hashValue = Cogs::hash(layer, hashValue);
      hashValue = Cogs::hash(depth, hashValue);
      hashValue = Cogs::hash(drawOrder, hashValue);
      hashValue = Cogs::hash(objectId, hashValue);
      hashValue = Cogs::hash(flags, hashValue);
      hashValue = Cogs::hash(stateChanges, hashValue);
      hashValue = Cogs::hash(blendState, hashValue);
      hashValue = Cogs::hash(depthState, hashValue);
      hashValue = Cogs::hash(rasterizerState, hashValue);
      hashValue = Cogs::hash(clipShapeIx, hashValue);
 
      return hashValue;
    }
  };
 
  typedef std::vector<RenderItem> RenderItems;
 
  
 
  struct RenderBatch
  {
    RenderBatch() : allItems(1024)
    {
      current = allItems.data();
    }
 
    RenderItem * current = nullptr;
 
    RenderItem * begin() { return allItems.data(); }
    RenderItem * end() { return current; }
    const RenderItem * begin() const { return allItems.data(); }
    const RenderItem * end() const { return current; }
    size_t size() const { return size_t(current - begin()); }
    bool empty() const { return begin() == end(); }
    RenderItem& operator[](size_t idx)
    {
      assert(idx < size());
      return begin()[idx];
    }
    const RenderItem& operator[](size_t idx) const
    {
      assert(idx < size());
      return begin()[idx];
    }
 
    void clear() { current = allItems.data(); }
 
    RenderItem& alloc()
    {
      const size_t sz = size();
      if (sz == allItems.size()) {
        allItems.resize(allItems.size() * 2);
        current = allItems.data() + sz;
      }
      return *current++;
    }
 
    RenderItem & createCustom()
    {
      RenderItem& item = alloc();
      item = {};
      item.cullingIndex = (uint32_t)-1;
      item.flags = RenderItemFlags::Custom;
      return item;
    }
 
  private:
    RenderItems allItems;
  public:
    size_t hash = 0;
    size_t generation = 0;
    size_t missing = (size_t)-1;
  };
 
  struct RenderList : public RenderResource
  {
    RenderList() : batches({ &batch }) {}
 
    RenderItem * begin() { return batch.begin(); }
    RenderItem * end() { return batch.end(); }
    const RenderItem * begin() const { return batch.begin(); }
    const RenderItem * end() const { return batch.end(); }
    size_t size() const { return batch.size(); }
    void clear()
    {
      batch.clear();
      batches = { &batch };
    }
 
    RenderItem & createCustom(const MeshStreamsLayout* streamsLayout)
    {
      RenderItem& rv = batch.createCustom();
      rv.streamsLayout = streamsLayout;
      return rv;
    }
 
    RenderBatch batch;
 
    std::vector<RenderBatch *> batches;
 
    RenderItems buckets[size_t(BucketType::Count)];
 
    size_t hash = 0;
    const struct CameraData * viewportData = nullptr;
    struct ListObjectBuffer* listObjectBuffer = nullptr;
    struct ClipShapeCache* clipShapeCache = nullptr;
  };
 
}
template<> inline Cogs::StringView getName<Cogs::Core::StateChangeFlags>() { return "StateChangeFlags"; }
template<> inline Cogs::StringView getName<Cogs::Core::BucketMask>() { return "BucketMask"; }