Working HECL shader generation on D3D11/12

hecl/extern/Athena

@@ -1 +1 @@
-Subproject commit df43b72f8ac860c6662896cd97498a4091a6174d
+Subproject commit 18e94dbc54cf1e88d7c5b697e96b05a1f583edee

hecl/extern/libBoo

@@ -1 +1 @@
-Subproject commit 742e062cf2f128baeb9533cd7fd41f4acb072001
+Subproject commit b97ad76c45b4965f3dd9f499e5975738714f5fa8

hecl/include/HECL/Backend/GX.hpp

@@ -351,7 +351,9 @@ struct GX : IBackend
             }
         }
 
-        for (int i=0 ; i<3 ; ++i)
+        /* Allocate from back for compatibility with Retro's
+         * extended shader arithmetic use */
+        for (int i=2 ; i>=0 ; --i)
             if (!(regMask & (1 << i)))
                 return i;
 
@@ -379,7 +381,9 @@ struct GX : IBackend
             }
         }
 
-        for (int i=0 ; i<3 ; ++i)
+        /* Allocate from back for compatibility with Retro's
+         * extended shader arithmetic use */
+        for (int i=2 ; i>=0 ; --i)
             if (!(regMask & (1 << i)))
                 return i;
 

hecl/include/HECL/Runtime.hpp

@@ -10,6 +10,8 @@
 
 namespace HECL
 {
+struct HMDLMeta;
+
 namespace Runtime
 {
 
@@ -75,6 +77,9 @@ public:
     bool getDepthWrite() const {return m_depthWrite;}
     bool getBackfaceCulling() const {return m_backfaceCulling;}
     uint64_t getMetaData() const {return m_meta;}
+
+    /* For shader constructors that require vertex format up-front (HLSL) */
+    boo::IVertexFormat* newVertexFormat(boo::IGraphicsDataFactory* factory) const;
 };
 
 /**
@@ -217,11 +222,15 @@ struct HMDLData
 {
     boo::IGraphicsBufferS* m_vbo;
     boo::IGraphicsBufferS* m_ibo;
-    boo::IVertexFormat* m_vtxFmt;
+    boo::IVertexFormat* m_vtxFmt = nullptr;
 
     HMDLData(boo::IGraphicsDataFactory* factory,
              const void* metaData, const void* vbo, const void* ibo);
 
+    /* For binding constructors that require vertex format up front (GLSL) */
+    static boo::IVertexFormat* NewVertexFormat(boo::IGraphicsDataFactory* factory, const HMDLMeta& meta,
+                                               boo::IGraphicsBuffer* vbo=nullptr, boo::IGraphicsBuffer* ibo=nullptr);
+
     boo::IShaderDataBinding* newShaderDataBindng(boo::IGraphicsDataFactory* factory,
                                                  boo::IShaderPipeline* shader,
                                                  size_t ubufCount, boo::IGraphicsBuffer** ubufs,

hecl/lib/Backend/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_library(HECLBackend
             GX.cpp
             ProgrammableCommon.cpp
-            GLSL.cpp)
+            GLSL.cpp
+            HLSL.cpp)

hecl/lib/CMakeLists.txt

@@ -21,6 +21,7 @@ add_library(HECLCommon
             ../include/HECL/Backend/GX.hpp
             ../include/HECL/Backend/ProgrammableCommon.hpp
             ../include/HECL/Backend/GLSL.hpp
+            ../include/HECL/Backend/HLSL.hpp
             ../include/HECL/Frontend.hpp
             ../include/HECL/Database.hpp
             ../include/HECL/Runtime.hpp

hecl/lib/Frontend/Parser.cpp

@@ -10,17 +10,17 @@ namespace Frontend
 
 void Parser::skipWhitespace(std::string::const_iterator& it)
 {
-    while (true)
+    while (it != m_source->cend())
     {
-        while (isspace(*it) && it != m_source->cend())
+        while (it != m_source->cend() && isspace(*it))
             ++it;
 
         /* Skip comment line */
-        if (*it == '#')
+        if (it != m_source->cend() && *it == '#')
         {
-            while (*it != '\n' && it != m_source->cend())
+            while (it != m_source->cend() && *it != '\n')
                 ++it;
-            if (*it == '\n')
+            if (it != m_source->cend() && *it == '\n')
                 ++it;
             continue;
         }

hecl/lib/Runtime/HMDL.cpp

@@ -22,12 +22,20 @@ HMDLData::HMDLData(boo::IGraphicsDataFactory* factory,
     m_vbo = factory->newStaticBuffer(boo::BufferUseVertex, vbo, meta.vertStride, meta.vertCount);
     m_ibo = factory->newStaticBuffer(boo::BufferUseIndex, ibo, 4, meta.indexCount);
 
+    if (factory->bindingNeedsVertexFormat())
+        m_vtxFmt = NewVertexFormat(factory, meta, m_vbo, m_ibo);
+}
+
+/* For binding constructors that require vertex format up front (GLSL) */
+boo::IVertexFormat* HMDLData::NewVertexFormat(boo::IGraphicsDataFactory* factory, const HMDLMeta& meta,
+                                              boo::IGraphicsBuffer* vbo, boo::IGraphicsBuffer* ibo)
+{
     size_t elemCount = 2 + meta.colorCount + meta.uvCount + meta.weightCount;
     std::unique_ptr<boo::VertexElementDescriptor[]> vdescs(new boo::VertexElementDescriptor[elemCount]);
     for (size_t i=0 ; i<elemCount ; ++i)
     {
-        vdescs[i].vertBuffer = m_vbo;
+        vdescs[i].vertBuffer = vbo;
-        vdescs[i].indexBuffer = m_ibo;
+        vdescs[i].indexBuffer = ibo;
     }
 
     vdescs[0].semantic = boo::VertexSemanticPosition;
@@ -52,7 +60,43 @@ HMDLData::HMDLData(boo::IGraphicsDataFactory* factory,
         vdescs[e].semanticIdx = i;
     }
 
-    m_vtxFmt = factory->newVertexFormat(elemCount, vdescs.get());
+    return factory->newVertexFormat(elemCount, vdescs.get());
+}
+
+/* For shader constructors that require vertex format up-front (HLSL) */
+boo::IVertexFormat* ShaderTag::newVertexFormat(boo::IGraphicsDataFactory *factory) const
+{
+    size_t elemCount = 2 + m_colorCount + m_uvCount + m_weightCount;
+    std::unique_ptr<boo::VertexElementDescriptor[]> vdescs(new boo::VertexElementDescriptor[elemCount]);
+    for (size_t i=0 ; i<elemCount ; ++i)
+    {
+        vdescs[i].vertBuffer = nullptr;
+        vdescs[i].indexBuffer = nullptr;
+    }
+
+    vdescs[0].semantic = boo::VertexSemanticPosition;
+    vdescs[1].semantic = boo::VertexSemanticNormal;
+    size_t e = 2;
+
+    for (size_t i=0 ; i<m_colorCount ; ++i, ++e)
+    {
+        vdescs[e].semantic = boo::VertexSemanticColor;
+        vdescs[e].semanticIdx = i;
+    }
+
+    for (size_t i=0 ; i<m_uvCount ; ++i, ++e)
+    {
+        vdescs[e].semantic = boo::VertexSemanticUV;
+        vdescs[e].semanticIdx = i;
+    }
+
+    for (size_t i=0 ; i<m_weightCount ; ++i, ++e)
+    {
+        vdescs[e].semantic = boo::VertexSemanticWeight;
+        vdescs[e].semanticIdx = i;
+    }
+
+    return factory->newVertexFormat(elemCount, vdescs.get());
 }
 
 }

hecl/lib/Runtime/ShaderCacheManager.cpp

@@ -12,6 +12,7 @@ namespace HECL
 namespace Runtime
 {
 IShaderBackendFactory* _NewGLSLBackendFactory(boo::IGraphicsDataFactory* gfxFactory);
+IShaderBackendFactory* _NewHLSLBackendFactory(boo::IGraphicsDataFactory* gfxFactory);
 
 static LogVisor::LogModule Log("ShaderCacheManager");
 static uint64_t IDX_MAGIC = SBig(uint64_t(0xDEADFEEDC001D00D));
@@ -109,8 +110,12 @@ ShaderCacheManager::ShaderCacheManager(const FileStoreManager& storeMgr,
     case boo::IGraphicsDataFactory::PlatformOGL:
         m_factory.reset(_NewGLSLBackendFactory(gfxFactory));
         break;
+    case boo::IGraphicsDataFactory::PlatformD3D11:
+    case boo::IGraphicsDataFactory::PlatformD3D12:
+        m_factory.reset(_NewHLSLBackendFactory(gfxFactory));
+        break;
     default:
-        Log.report(LogVisor::FatalError, "unsupported backend %s", gfxFactory->platformName());
+        Log.report(LogVisor::FatalError, _S("unsupported backend %s"), gfxFactory->platformName());
     }
 
     reload();