Common.h

#pragma once
 
#include "Foundation/HashFunctions.h"
 
// Use to ensure arrays used for mapping enumeration values are of correct size.
#define STATIC_ASSERT_MAPPING(mappingArray, sourceEnum) static_assert(sizeof(mappingArray) / sizeof(mappingArray[0]) == (int)sourceEnum, "Array size of " #mappingArray " must match number of enumerations in mapping array.");
 
namespace Cogs
{
 
  struct NoConversion {};
 
 
  template<typename Type, typename Convertible = NoConversion>
  struct Handle_t
  {
    typedef int64_t handle_type;
 
    Handle_t() : handle(-1) {}
 
    Handle_t(const Handle_t & other) : handle(other.handle) {}
 
    explicit Handle_t(const handle_type& handle) : handle(handle) {}
 
    Handle_t(const Convertible & other) : handle(other.handle) {}
 
    Handle_t & operator=(const Handle_t & other) { this->handle = other.handle; return *this; }
 
    [[nodiscard]] bool operator==(const Handle_t & other) const { return this->handle == other.handle; }
 
    explicit operator bool() const { return handle != 0 && handle != -1; }
 
    operator Convertible() { return Convertible(this->handle); };
 
    handle_type handle;
 
    const static Handle_t NoHandle;
 
    const static Handle_t InvalidHandle;
  };
 
  template<typename T, typename U>
  const Handle_t<T, U> Handle_t<T, U>::NoHandle = Handle_t<T, U>(0);
 
  template<typename T, typename U>
  const Handle_t<T, U> Handle_t<T, U>::InvalidHandle = Handle_t<T, U>(-1);
}
 
namespace std
{
  template<typename T, typename U>
  struct hash<Cogs::Handle_t<T, U>>
  {
    std::size_t operator()(const Cogs::Handle_t<T, U> & handle) const
    {
      return std::hash<typename Cogs::Handle_t<T, U>::handle_type>()(handle.handle);
    }
  };
}
 
namespace Cogs
{
  struct PrimitiveType
  {
    enum EPrimitiveType
    {
      TriangleList = 0,
      TriangleStrip,
      LineList,
      LineStrip,
      PointList,
      TriangleListAdjacency,
      TriangleStripAdjacency,
      LineListAdjacency,
      LineStripAdjacency,
 
      ControlPoint1PatchList,
      ControlPoint2PatchList,
      ControlPoint3PatchList,
      ControlPoint4PatchList,
 
      // Provided for size comparisons.
      PrimitiveType_Size,
    };
  };
 
  struct Framebuffer
  {
    enum EFrameBuffer
    {
      Front = 0,
      Back
    };
  };
 
  struct BlendFlags
  {
    enum EBlendFlags
    {
      None = 0,
      AlphaToCoverage = 1 << 0,
      IndependentBlend = 1 << 1
    };
  };
 
  struct PresentFlags
  {
    enum EPresentFlags
    {
      None = 0,
      Default = None,
      NoSwap = 0x0001L,
    };
  };
 
  enum class Axis {
    PositiveX,
    NegativeX,
    PositiveY,
    NegativeY,
    PositiveZ,
    NegativeZ,
 
    Count,
    Unknown = -1,
  };
 
 
  struct InputLayoutTag {};
  struct BufferTag {};
  struct TextureTag {};
  struct SamplerTag {};
  struct EffectTag {};
  struct ShaderTag {};
  struct RenderPipelineTag {};
  struct ComputePipelineTag {};
  struct RenderTargetTag {};
  struct DepthStencilTag {};
  struct ConstantBufferBindingTag {};
  struct VariableBindingTag {};
  struct TextureBindingTag {};
  struct SamplerStateBindingTag {};
  struct BufferBindingTag {};
  struct TextureViewTag {};
  struct VertexFormatTag {};
  struct VertexArrayObjectTag {};
  struct FenceTag {};
 
 
  typedef Handle_t<struct RasterizerState> RasterizerStateHandle;
  typedef Handle_t<struct DepthStencilState> DepthStencilStateHandle;
  typedef Handle_t<struct BlendState> BlendStateHandle;
 
  typedef Handle_t<InputLayoutTag> InputLayoutHandle;
 
  typedef Handle_t<BufferTag> BufferHandle;
  typedef Handle_t<BufferTag, BufferHandle> VertexBufferHandle;
  typedef Handle_t<BufferTag, BufferHandle> IndexBufferHandle;
 
  typedef Handle_t<VertexFormatTag> VertexFormatHandle;
 
  typedef Handle_t<VertexArrayObjectTag> VertexArrayObjectHandle;
 
  typedef intptr_t TextureNativeHandle;
  typedef Handle_t<TextureTag> TextureHandle;
  typedef Handle_t<SamplerTag> SamplerStateHandle;
 
  typedef Handle_t<EffectTag> EffectHandle;
  typedef Handle_t<ShaderTag> ShaderHandle;
  typedef Handle_t<RenderPipelineTag> RenderPipelineHandle;
  typedef Handle_t<ComputePipelineTag> ComputePipelineHandle;
 
  typedef Handle_t<RenderTargetTag> RenderTargetHandle;
  typedef Handle_t<DepthStencilTag> DepthStencilHandle;
 
  typedef Handle_t<VariableBindingTag> EffectVariableHandle;
  typedef Handle_t<ConstantBufferBindingTag> ConstantBufferBindingHandle;
  typedef Handle_t<TextureBindingTag> TextureBindingHandle;
  typedef Handle_t<SamplerStateBindingTag> SamplerStateBindingHandle;
  typedef Handle_t<BufferBindingTag> BufferBindingHandle;
 
  typedef Handle_t<TextureViewTag> TextureViewHandle;
 
  typedef Handle_t<FenceTag> FenceHandle;
 
  template<typename T>
  inline bool HandleIsValid(const Handle_t<T> handle)
  {
    return (handle != Handle_t<T>::NoHandle && handle != Handle_t<T>::InvalidHandle);
  }
 
  template<typename T, typename U>
  inline bool HandleIsValid(const Handle_t<T, U> handle)
  {
    return (handle != Handle_t<T, U>::NoHandle && handle != Handle_t<T, U>::InvalidHandle);
  }
 
  inline bool isDebug()
  {
#ifdef _DEBUG
    return true;
#else
    return false;
#endif
  }
}