text: /*
   * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
   * 
   * SPDX-License-Identifier: Apache-2.0 OR MIT
   *
   */
  
  #include "StdAfx.h"
  
  #include <Asset/BlastAsset.h>
  #include <AzCore/std/parallel/lock.h>
  #include <Blast/BlastSystemBus.h>
  #include <NvBlastExtAssetUtils.h>
  #include <NvBlastExtPxSerialization.h>
  #include <NvBlastExtSerialization.h>
  #include <NvBlastExtTkSerialization.h>
  #include <NvBlastTkAsset.h>
  #include <NvBlastTypes.h>
  
  namespace Blast
  {
      AZStd::mutex BlastAsset::s_assetCreationMutex;
  
      BlastAsset::BlastAsset(Nv::Blast::ExtPxAsset* pxAsset, NvBlastExtDamageAccelerator* damageAccelerator)
          : m_pxAsset(pxAsset)
          , m_damageAccelerator(damageAccelerator)
          , m_bondHealthMax(0)
      {
      }
  
      bool BlastAsset::LoadFromBuffer(void* buffer, size_t bytesSize)
      {
          Nv::Blast::ExtSerialization* serialization = nullptr;
  
          BlastSystemRequestBus::BroadcastResult(serialization, &BlastSystemRequestBus::Events::GetExtSerialization);
  
          if (serialization == nullptr)
          {
              AZ_Error("Blast", false, "Trying to load blast asset before blast system has initialized.");
              return false;
          }
  
          AZ::u32 objectTypeId;
          void* asset = nullptr;
          {
              AZStd::lock_guard<AZStd::mutex> lock(s_assetCreationMutex);
              asset = serialization->deserializeFromBuffer(buffer, bytesSize, &objectTypeId);
          }
  
          if (asset == nullptr)
          {
              AZ_Error("Blast", asset != nullptr, "can't load .blast file.");
              return false;
          }
          else if (objectTypeId == Nv::Blast::ExtPxObjectTypeID::Asset)
          {
              m_pxAsset.reset(reinterpret_cast<Nv::Blast::ExtPxAsset*>(asset));
              const Nv::Blast::TkAsset& tkAsset = m_pxAsset->getTkAsset();
              NvBlastAsset* llAsset = const_cast<NvBlastAsset*>(tkAsset.getAssetLL());
              m_damageAccelerator.reset(NvBlastExtDamageAcceleratorCreate(llAsset, 3));
              m_pxAsset->setAccelerator(m_damageAccelerator.get());
          }
          else
          {
              // in this case we'll want to extract the physics meshes from the scene file.
              // We don't necessarily have access to the mesh data though, so if we want to support this,
              // we'll need to come up with a way to associate with the mesh data
              // See BlastAssetModel in the SDK sample for how to create that data
              AZ_Error("Blast", false, "We currently don't support loading Non-ExtPx objects");
              return false;
          }
  
          // Initialize maximum bond health
          const auto& actorDesc = m_pxAsset->getDefaultActorDesc();
          if (actorDesc.initialBondHealths)
          {
              m_bondHealthMax = std::numeric_limits<float>::min();
              const uint32_t bondCount = m_pxAsset->getTkAsset().getBondCount();
              for (uint32_t i = 0; i < bondCount; ++i)
              {
                  m_bondHealthMax = std::max<float>(m_bondHealthMax, actorDesc.initialBondHealths[i]);
              }
          }
          else
          {
              m_bondHealthMax = actorDesc.uniformInitialBondHealth;
          }
  
          return true;
      }
  } // namespace Blast
  