text: /*
  Open Asset Import Library (assimp)
  ----------------------------------------------------------------------
  
  Copyright (c) 2006-2016, 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 Importer.h mostly internal stuff for use by #Assimp::Importer */
  #ifndef INCLUDED_AI_IMPORTER_H
  #define INCLUDED_AI_IMPORTER_H
  
  #include <map>
  #include <string>
  #include <vector>
  #include <assimp/matrix4x4.h>
  
  struct aiScene;
  
  namespace Assimp    {
      class ProgressHandler;
      class IOSystem;
      class BaseImporter;
      class BaseProcess;
      class SharedPostProcessInfo;
  
  
  //! @cond never
  // ---------------------------------------------------------------------------
  /** @brief Internal PIMPL implementation for Assimp::Importer
   *
   *  Using this idiom here allows us to drop the dependency from
   *  std::vector and std::map in the public headers. Furthermore we are dropping
   *  any STL interface problems caused by mismatching STL settings. All
   *  size calculation are now done by us, not the app heap. */
  class ImporterPimpl
  {
  public:
  
      // Data type to store the key hash
      typedef unsigned int KeyType;
  
      // typedefs for our four configuration maps.
      // We don't need more, so there is no need for a generic solution
      typedef std::map<KeyType, int> IntPropertyMap;
      typedef std::map<KeyType, ai_real> FloatPropertyMap;
      typedef std::map<KeyType, std::string> StringPropertyMap;
      typedef std::map<KeyType, std::wstring> WStringPropertyMap;
      typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
  
  public:
  
      /** IO handler to use for all file accesses. */
      IOSystem* mIOHandler;
      bool mIsDefaultHandler;
  
      /** Progress handler for feedback. */
      ProgressHandler* mProgressHandler;
      bool mIsDefaultProgressHandler;
  
      /** Format-specific importer worker objects - one for each format we can read.*/
      std::vector< BaseImporter* > mImporter;
  
      /** Post processing steps we can apply at the imported data. */
      std::vector< BaseProcess* > mPostProcessingSteps;
  
      /** The imported data, if ReadFile() was successful, NULL otherwise. */
      aiScene* mScene;
  
      /** The error description, if there was one. */
      std::string mErrorString;
  
      /** List of integer properties */
      IntPropertyMap mIntProperties;
  
      /** List of floating-point properties */
      FloatPropertyMap mFloatProperties;
  
      /** List of string properties */
      StringPropertyMap mStringProperties;
  
      /** List of string properties */
      WStringPropertyMap mWStringProperties;
  
      /** List of Matrix properties */
      MatrixPropertyMap mMatrixProperties;
  
      /** Used for testing - extra verbose mode causes the ValidateDataStructure-Step
       *  to be executed before and after every single postprocess step */
      bool bExtraVerbose;
  
      /** Used by post-process steps to share data */
      SharedPostProcessInfo* mPPShared;
  };
  //! @endcond
  
  
  struct BatchData;
  
  // ---------------------------------------------------------------------------
  /** FOR IMPORTER PLUGINS ONLY: A helper class to the pleasure of importers
   *  that need to load many external meshes recursively.
   *
   *  The class uses several threads to load these meshes (or at least it
   *  could, this has not yet been implemented at the moment).
   *
   *  @note The class may not be used by more than one thread*/
  class BatchLoader
  {
      // friend of Importer
  
  public:
  
      //! @cond never
      // -------------------------------------------------------------------
      /** Wraps a full list of configuration properties for an importer.
       *  Properties can be set using SetGenericProperty */
      struct PropertyMap
      {
          ImporterPimpl::IntPropertyMap     ints;
          ImporterPimpl::FloatPropertyMap   floats;
          ImporterPimpl::StringPropertyMap  strings;
          ImporterPimpl::WStringPropertyMap wstrings;
          ImporterPimpl::MatrixPropertyMap  matrices;
  
          bool operator == (const PropertyMap& prop) const {
              // fixme: really isocpp? gcc complains
              return ints == prop.ints && floats == prop.floats && strings == prop.strings && wstrings == prop.wstrings && matrices == prop.matrices;
          }
  
          bool empty () const {
              return ints.empty() && floats.empty() && strings.empty() && wstrings.empty() && matrices.empty();
          }
      };
      //! @endcond
  
  public:
  
  
      // -------------------------------------------------------------------
      /** Construct a batch loader from a given IO system to be used
       *  to access external files */
      explicit BatchLoader(IOSystem* pIO);
      ~BatchLoader();
  
  
      // -------------------------------------------------------------------
      /** Add a new file to the list of files to be loaded.
       *  @param file File to be loaded
       *  @param steps Post-processing steps to be executed on the file
       *  @param map Optional configuration properties
       *  @return 'Load request channel' - an unique ID that can later
       *    be used to access the imported file data.
       *  @see GetImport */
      unsigned int AddLoadRequest (
          const std::string& file,
          unsigned int steps = 0,
          const PropertyMap* map = NULL
          );
  
  
      // -------------------------------------------------------------------
      /** Get an imported scene.
       *  This polls the import from the internal request list.
       *  If an import is requested several times, this function
       *  can be called several times, too.
       *
       *  @param which LRWC returned by AddLoadRequest().
       *  @return NULL if there is no scene with this file name
       *  in the queue of the scene hasn't been loaded yet. */
      aiScene* GetImport(
          unsigned int which
          );
  
  
      // -------------------------------------------------------------------
      /** Waits until all scenes have been loaded. This returns
       *  immediately if no scenes are queued.*/
      void LoadAll();
  
  private:
  
      // No need to have that in the public API ...
      BatchData* data;
  };
  
  }
  
  
  
  #endif
  