text: /*
  Open Asset Import Library (assimp)
  ----------------------------------------------------------------------
  
  Copyright (c) 2006-2017, assimp team
  
  All rights reserved.
  
  Redistribution and use of this software in source and binary forms,
  with or without modification, are permitted provided that the
  following conditions are met:
  
  * Redistributions of source code must retain the above
    copyright notice, this list of conditions and the
    following disclaimer.
  
  * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the
    following disclaimer in the documentation and/or other
    materials provided with the distribution.
  
  * Neither the name of the assimp team, nor the names of its
    contributors may be used to endorse or promote products
    derived from this software without specific prior
    written permission of the assimp team.
  
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  ----------------------------------------------------------------------
  */
  
  /** @file Declares a helper class, "SceneCombiner" providing various
   *  utilities to merge scenes.
   */
  #ifndef AI_SCENE_COMBINER_H_INC
  #define AI_SCENE_COMBINER_H_INC
  
  #include <assimp/ai_assert.h>
  #include <assimp/types.h>
  #include <assimp/Defines.h>
  #include <stddef.h>
  #include <set>
  #include <list>
  #include <stdint.h>
  
  #include <vector>
  
  struct aiScene;
  struct aiNode;
  struct aiMaterial;
  struct aiTexture;
  struct aiCamera;
  struct aiLight;
  struct aiMetadata;
  struct aiBone;
  struct aiMesh;
  struct aiAnimation;
  struct aiNodeAnim;
  
  namespace Assimp    {
  
  // ---------------------------------------------------------------------------
  /** \brief Helper data structure for SceneCombiner.
   *
   *  Describes to which node a scene must be attached to.
   */
  struct AttachmentInfo
  {
      AttachmentInfo()
          :   scene           (NULL)
          ,   attachToNode    (NULL)
      {}
  
      AttachmentInfo(aiScene* _scene, aiNode* _attachToNode)
          :   scene           (_scene)
          ,   attachToNode    (_attachToNode)
      {}
  
      aiScene* scene;
      aiNode*  attachToNode;
  };
  
  // ---------------------------------------------------------------------------
  struct NodeAttachmentInfo
  {
      NodeAttachmentInfo()
          :   node            (NULL)
          ,   attachToNode    (NULL)
          ,   resolved        (false)
          ,   src_idx         (SIZE_MAX)
      {}
  
      NodeAttachmentInfo(aiNode* _scene, aiNode* _attachToNode,size_t idx)
          :   node            (_scene)
          ,   attachToNode    (_attachToNode)
          ,   resolved        (false)
          ,   src_idx         (idx)
      {}
  
      aiNode*  node;
      aiNode*  attachToNode;
      bool     resolved;
      size_t   src_idx;
  };
  
  // ---------------------------------------------------------------------------
  /** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES
   *  Generate unique names for all named scene items
   */
  #define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES      0x1
  
  /** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES
   *  Generate unique names for materials, too.
   *  This is not absolutely required to pass the validation.
   */
  #define AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES   0x2
  
  /** @def AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY
   * Use deep copies of duplicate scenes
   */
  #define AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY   0x4
  
  /** @def AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS
   * If attachment nodes are not found in the given master scene,
   * search the other imported scenes for them in an any order.
   */
  #define AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS 0x8
  
  /** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY
   * Can be combined with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES.
   * Unique names are generated, but only if this is absolutely
   * required to avoid name conflicts.
   */
  #define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY 0x10
  
  typedef std::pair<aiBone*,unsigned int> BoneSrcIndex;
  
  // ---------------------------------------------------------------------------
  /** @brief Helper data structure for SceneCombiner::MergeBones.
   */
  struct BoneWithHash : public std::pair<uint32_t,aiString*>  {
      std::vector<BoneSrcIndex> pSrcBones;
  };
  
  // ---------------------------------------------------------------------------
  /** @brief Utility for SceneCombiner
   */
  struct SceneHelper
  {
      SceneHelper ()
          : scene     (NULL)
          , idlen     (0)
      {
          id[0] = 0;
      }
  
      explicit SceneHelper (aiScene* _scene)
          : scene     (_scene)
          , idlen     (0)
      {
          id[0] = 0;
      }
  
      AI_FORCE_INLINE aiScene* operator-> () const
      {
          return scene;
      }
  
      // scene we're working on
      aiScene* scene;
  
      // prefix to be added to all identifiers in the scene ...
      char id [32];
  
      // and its strlen()
      unsigned int idlen;
  
      // hash table to quickly check whether a name is contained in the scene
      std::set<unsigned int> hashes;
  };
  
  // ---------------------------------------------------------------------------
  /** \brief Static helper class providing various utilities to merge two
   *    scenes. It is intended as internal utility and NOT for use by
   *    applications.
   *
   * The class is currently being used by various postprocessing steps
   * and loaders (ie. LWS).
   */
  class ASSIMP_API SceneCombiner {
      // class cannot be instanced
      SceneCombiner() {
          // empty
      }
  
      ~SceneCombiner() {
          // empty
      }
  
  public:
      // -------------------------------------------------------------------
      /** Merges two or more scenes.
       *
       *  @param dest  Receives a pointer to the destination scene. If the
       *    pointer doesn't point to NULL when the function is called, the
       *    existing scene is cleared and refilled.
       *  @param src Non-empty list of scenes to be merged. The function
       *    deletes the input scenes afterwards. There may be duplicate scenes.
       *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
       */
      static void MergeScenes(aiScene** dest,std::vector<aiScene*>& src,
          unsigned int flags = 0);
  
      // -------------------------------------------------------------------
      /** Merges two or more scenes and attaches all scenes to a specific
       *  position in the node graph of the master scene.
       *
       *  @param dest Receives a pointer to the destination scene. If the
       *    pointer doesn't point to NULL when the function is called, the
       *    existing scene is cleared and refilled.
       *  @param master Master scene. It will be deleted afterwards. All
       *    other scenes will be inserted in its node graph.
       *  @param src Non-empty list of scenes to be merged along with their
       *    corresponding attachment points in the master scene. The function
       *    deletes the input scenes afterwards. There may be duplicate scenes.
       *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
       */
      static void MergeScenes(aiScene** dest, aiScene* master,
          std::vector<AttachmentInfo>& src,
          unsigned int flags = 0);
  
      // -------------------------------------------------------------------
      /** Merges two or more meshes
       *
       *  The meshes should have equal vertex formats. Only components
       *  that are provided by ALL meshes will be present in the output mesh.
       *  An exception is made for VColors - they are set to black. The
       *  meshes should have the same material indices, too. The output
       *  material index is always the material index of the first mesh.
       *
       *  @param dest Destination mesh. Must be empty.
       *  @param flags Currently no parameters
       *  @param begin First mesh to be processed
       *  @param end Points to the mesh after the last mesh to be processed
       */
      static void MergeMeshes(aiMesh** dest,unsigned int flags,
          std::vector<aiMesh*>::const_iterator begin,
          std::vector<aiMesh*>::const_iterator end);
  
      // -------------------------------------------------------------------
      /** Merges two or more bones
       *
       *  @param out Mesh to receive the output bone list
       *  @param flags Currently no parameters
       *  @param begin First mesh to be processed
       *  @param end Points to the mesh after the last mesh to be processed
       */
      static void MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
          std::vector<aiMesh*>::const_iterator end);
  
      // -------------------------------------------------------------------
      /** Merges two or more materials
       *
       *  The materials should be complementary as much as possible. In case
       *  of a property present in different materials, the first occurrence
       *  is used.
       *
       *  @param dest Destination material. Must be empty.
       *  @param begin First material to be processed
       *  @param end Points to the material after the last material to be processed
       */
      static void MergeMaterials(aiMaterial** dest,
          std::vector<aiMaterial*>::const_iterator begin,
          std::vector<aiMaterial*>::const_iterator end);
  
      // -------------------------------------------------------------------
      /** Builds a list of uniquely named bones in a mesh list
       *
       *  @param asBones Receives the output list
       *  @param it First mesh to be processed
       *  @param end Last mesh to be processed
       */
      static void BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
          std::vector<aiMesh*>::const_iterator it,
          std::vector<aiMesh*>::const_iterator end);
  
      // -------------------------------------------------------------------
      /** Add a name prefix to all nodes in a scene.
       *
       *  @param Current node. This function is called recursively.
       *  @param prefix Prefix to be added to all nodes
       *  @param len STring length
       */
      static void AddNodePrefixes(aiNode* node, const char* prefix,
          unsigned int len);
  
      // -------------------------------------------------------------------
      /** Add an offset to all mesh indices in a node graph
       *
       *  @param Current node. This function is called recursively.
       *  @param offset Offset to be added to all mesh indices
       */
      static void OffsetNodeMeshIndices (aiNode* node, unsigned int offset);
  
      // -------------------------------------------------------------------
      /** Attach a list of node graphs to well-defined nodes in a master
       *  graph. This is a helper for MergeScenes()
       *
       *  @param master Master scene
       *  @param srcList List of source scenes along with their attachment
       *    points. If an attachment point is NULL (or does not exist in
       *    the master graph), a scene is attached to the root of the master
       *    graph (as an additional child node)
       *  @duplicates List of duplicates. If elem[n] == n the scene is not
       *    a duplicate. Otherwise elem[n] links scene n to its first occurrence.
       */
      static void AttachToGraph ( aiScene* master,
          std::vector<NodeAttachmentInfo>& srcList);
  
      static void AttachToGraph (aiNode* attach,
          std::vector<NodeAttachmentInfo>& srcList);
  
  
      // -------------------------------------------------------------------
      /** Get a deep copy of a scene
       *
       *  @param dest Receives a pointer to the destination scene
       *  @param src Source scene - remains unmodified.
       */
      static void CopyScene(aiScene** dest,const aiScene* source,bool allocate = true);
  
  
      // -------------------------------------------------------------------
      /** Get a flat copy of a scene
       *
       *  Only the first hierarchy layer is copied. All pointer members of
       *  aiScene are shared by source and destination scene.  If the
       *    pointer doesn't point to NULL when the function is called, the
       *    existing scene is cleared and refilled.
       *  @param dest Receives a pointer to the destination scene
       *  @param src Source scene - remains unmodified.
       */
      static void CopySceneFlat(aiScene** dest,const aiScene* source);
  
  
      // -------------------------------------------------------------------
      /** Get a deep copy of a mesh
       *
       *  @param dest Receives a pointer to the destination mesh
       *  @param src Source mesh - remains unmodified.
       */
      static void Copy     (aiMesh** dest, const aiMesh* src);
  
      // similar to Copy():
      static void Copy  (aiMaterial** dest, const aiMaterial* src);
      static void Copy  (aiTexture** dest, const aiTexture* src);
      static void Copy  (aiAnimation** dest, const aiAnimation* src);
      static void Copy  (aiCamera** dest, const aiCamera* src);
      static void Copy  (aiBone** dest, const aiBone* src);
      static void Copy  (aiLight** dest, const aiLight* src);
      static void Copy  (aiNodeAnim** dest, const aiNodeAnim* src);
      static void Copy  (aiMetadata** dest, const aiMetadata* src);
  
      // recursive, of course
      static void Copy     (aiNode** dest, const aiNode* src);
  
  
  private:
  
      // -------------------------------------------------------------------
      // Same as AddNodePrefixes, but with an additional check
      static void AddNodePrefixesChecked(aiNode* node, const char* prefix,
          unsigned int len,
          std::vector<SceneHelper>& input,
          unsigned int cur);
  
      // -------------------------------------------------------------------
      // Add node identifiers to a hashing set
      static void AddNodeHashes(aiNode* node, std::set<unsigned int>& hashes);
  
  
      // -------------------------------------------------------------------
      // Search for duplicate names
      static bool FindNameMatch(const aiString& name,
          std::vector<SceneHelper>& input, unsigned int cur);
  };
  
  }
  
  #endif // !! AI_SCENE_COMBINER_H_INC
  