C API for GLTFLoader

1 files changed, 51 insertions, 24 deletions

diff --git a/AssetLoader/src/GLTFLoader.cpp b/AssetLoader/src/GLTFLoader.cpp
index b000caa..1c546f7 100644
--- a/AssetLoader/src/GLTFLoader.cpp
+++ b/AssetLoader/src/GLTFLoader.cpp
@@ -246,9 +246,9 @@ void Node::UpdateTransforms()
 
 
 
-Model::Model(IRenderDevice*    pDevice,
-             IDeviceContext*   pContext,
-             const CreateInfo& CI)
+Model::Model(IRenderDevice*              pDevice,
+             IDeviceContext*             pContext,
+             const IGLTFModelCreateInfo& CI)
 {
     LoadFromFile(pDevice, pContext, CI);
 }
@@ -710,7 +710,7 @@ static float GetTextureAlphaCutoffValue(const tinygltf::Model& gltf_model, int T
 void Model::LoadTextures(IRenderDevice*         pDevice,
                          const tinygltf::Model& gltf_model,
                          const std::string&     BaseDir,
-                         TextureCacheType*      pTextureCache,
+                         GLTF_TextureCacheType* pTextureCache,
                          ResourceManager*       pResourceMgr)
 {
     for (const tinygltf::Texture& gltf_tex : gltf_model.textures)
@@ -1021,7 +1021,7 @@ void Model::PrepareGPUResources(IRenderDevice* pDevice, IDeviceContext* pCtx)
         }
     }
 
-    auto UpdateBuffer = [&](BUFFER_ID BuffId) //
+    auto UpdateBuffer = [&](GLTF_BUFFER_ID BuffId) //
     {
         auto&    BuffInfo = Buffers[BuffId];
         IBuffer* pBuffer  = nullptr;
@@ -1052,14 +1052,14 @@ void Model::PrepareGPUResources(IRenderDevice* pDevice, IDeviceContext* pCtx)
             if (Buffers[BuffId].pBuffer != nullptr)
             {
                 VERIFY_EXPR(Buffers[BuffId].pBuffer == pBuffer);
-                Barriers.emplace_back(StateTransitionDesc{pBuffer, RESOURCE_STATE_UNKNOWN, BuffId == BUFFER_ID_INDEX ? RESOURCE_STATE_INDEX_BUFFER : RESOURCE_STATE_VERTEX_BUFFER, true});
+                Barriers.emplace_back(StateTransitionDesc{pBuffer, RESOURCE_STATE_UNKNOWN, BuffId == GLTF_BUFFER_ID_INDEX ? RESOURCE_STATE_INDEX_BUFFER : RESOURCE_STATE_VERTEX_BUFFER, true});
             }
         }
     };
 
-    UpdateBuffer(BUFFER_ID_VERTEX_BASIC_ATTRIBS);
-    UpdateBuffer(BUFFER_ID_VERTEX_SKIN_ATTRIBS);
-    UpdateBuffer(BUFFER_ID_INDEX);
+    UpdateBuffer(GLTF_BUFFER_ID_VERTEX_BASIC_ATTRIBS);
+    UpdateBuffer(GLTF_BUFFER_ID_VERTEX_SKIN_ATTRIBS);
+    UpdateBuffer(GLTF_BUFFER_ID_INDEX);
 
     if (!Barriers.empty())
         pCtx->TransitionResourceStates(static_cast<Uint32>(Barriers.size()), Barriers.data());
@@ -1195,11 +1195,11 @@ void Model::LoadMaterials(const tinygltf::Model& gltf_model)
                 const tinygltf::Parameter& param = alpha_mode_it->second;
                 if (param.string_value == "BLEND")
                 {
-                    Mat.Attribs.AlphaMode = Material::ALPHA_MODE_BLEND;
+                    Mat.Attribs.AlphaMode = GLTF_MAT_ALPHA_MODE_BLEND;
                 }
                 if (param.string_value == "MASK")
                 {
-                    Mat.Attribs.AlphaMode   = Material::ALPHA_MODE_MASK;
+                    Mat.Attribs.AlphaMode   = GLTF_MAT_ALPHA_MODE_MASK;
                     Mat.Attribs.AlphaCutoff = 0.5f;
                 }
             }
@@ -1434,8 +1434,8 @@ namespace
 
 struct ImageLoaderData
 {
-    Model::TextureCacheType* const pTextureCache;
-    ResourceManager* const         pResourceMgr;
+    GLTF_TextureCacheType* const pTextureCache;
+    ResourceManager* const       pResourceMgr;
 
     std::vector<RefCntAutoPtr<IObject>> TexturesHold;
 
@@ -1699,9 +1699,9 @@ bool ReadWholeFile(std::vector<unsigned char>* out,
 
 } // namespace Callbacks
 
-void Model::LoadFromFile(IRenderDevice*    pDevice,
-                         IDeviceContext*   pContext,
-                         const CreateInfo& CI)
+void Model::LoadFromFile(IRenderDevice*              pDevice,
+                         IDeviceContext*             pContext,
+                         const IGLTFModelCreateInfo& CI)
 {
     if (CI.FileName == nullptr || *CI.FileName == 0)
         LOG_ERROR_AND_THROW("File path must not be empty");
@@ -1799,7 +1799,7 @@ void Model::LoadFromFile(IRenderDevice*    pDevice,
 
     Extensions = gltf_model.extensionsUsed;
 
-    auto CreateBuffer = [&](BUFFER_ID BuffId, const void* pData, size_t Size, BIND_FLAGS BindFlags, const char* Name) //
+    auto CreateBuffer = [&](GLTF_BUFFER_ID BuffId, const void* pData, size_t Size, BIND_FLAGS BindFlags, const char* Name) //
     {
         VERIFY_EXPR(Size > 0);
 
@@ -1809,13 +1809,13 @@ void Model::LoadFromFile(IRenderDevice*    pDevice,
             Uint32 CacheBufferIndex = 0;
             switch (BuffId)
             {
-                case BUFFER_ID_INDEX:
+                case GLTF_BUFFER_ID_INDEX:
                     CacheBufferIndex = CI.pCacheInfo->IndexBufferIdx;
                     break;
-                case BUFFER_ID_VERTEX_BASIC_ATTRIBS:
+                case GLTF_BUFFER_ID_VERTEX_BASIC_ATTRIBS:
                     CacheBufferIndex = CI.pCacheInfo->VertexBuffer0Idx;
                     break;
-                case BUFFER_ID_VERTEX_SKIN_ATTRIBS:
+                case GLTF_BUFFER_ID_VERTEX_SKIN_ATTRIBS:
                     CacheBufferIndex = CI.pCacheInfo->VertexBuffer1Idx;
                     break;
                 default:
@@ -1840,18 +1840,18 @@ void Model::LoadFromFile(IRenderDevice*    pDevice,
         }
     };
 
-    CreateBuffer(BUFFER_ID_VERTEX_BASIC_ATTRIBS, VertexBasicData.data(), VertexBasicData.size() * sizeof(VertexBasicData[0]),
+    CreateBuffer(GLTF_BUFFER_ID_VERTEX_BASIC_ATTRIBS, VertexBasicData.data(), VertexBasicData.size() * sizeof(VertexBasicData[0]),
                  BIND_VERTEX_BUFFER, "GLTF vertex attribs 0 buffer");
 
     if (!VertexSkinData.empty())
     {
-        CreateBuffer(BUFFER_ID_VERTEX_SKIN_ATTRIBS, VertexSkinData.data(), VertexSkinData.size() * sizeof(VertexSkinData[0]),
+        CreateBuffer(GLTF_BUFFER_ID_VERTEX_SKIN_ATTRIBS, VertexSkinData.data(), VertexSkinData.size() * sizeof(VertexSkinData[0]),
                      BIND_VERTEX_BUFFER, "GLTF vertex attribs 1 buffer");
     }
 
     if (!IndexData.empty())
     {
-        CreateBuffer(BUFFER_ID_INDEX, IndexData.data(), IndexData.size() * sizeof(IndexData[0]),
+        CreateBuffer(GLTF_BUFFER_ID_INDEX, IndexData.data(), IndexData.size() * sizeof(IndexData[0]),
                      BIND_INDEX_BUFFER, "GLTF index buffer");
     }
 
@@ -1989,8 +1989,9 @@ void Model::UpdateAnimation(Uint32 index, float time)
     }
 }
 
-void Model::Transform(const float4x4& Matrix)
+void Model::Transform(const float* _Matrix)
 {
+    auto Matrix = float4x4::MakeMatrix(_Matrix);
     for (auto& root_node : Nodes)
     {
         root_node->Matrix *= Matrix;
@@ -2033,7 +2034,33 @@ Node* Model::NodeFromIndex(uint32_t index)
     return nodeFound;
 }
 
+API_QUALIFIER
+IGLTFModel* IGLTFModel_Create(IRenderDevice*              pDevice,
+                              IDeviceContext*             pCtx,
+                              const IGLTFModelCreateInfo* CI) {
+    return new Model(pDevice, pCtx, *CI);
+}
+
+API_QUALIFIER
+void IGLTFModel_Destroy(IGLTFModel* model) {
+    delete model;
+}
 
 } // namespace GLTF
 
 } // namespace Diligent
+
+extern "C"
+{
+    API_QUALIFIER
+    Diligent::GLTF::IGLTFModel* Diligent_IGLTFModel_Create(Diligent::IRenderDevice*                    pDevice,
+                                                           Diligent::IDeviceContext*                   pCtx,
+                                                           const Diligent::GLTF::IGLTFModelCreateInfo* CI) {
+        return Diligent::GLTF::IGLTFModel_Create(pDevice, pCtx, CI);
+    }
+
+    API_QUALIFIER
+    void Diligent_IGLTFModel_Destroy(Diligent::GLTF::IGLTFModel* model) {
+        Diligent::GLTF::IGLTFModel_Destroy(model);
+    }
+}