vrshoot
view libs/assimp/assimp/Importer.hpp @ 0:b2f14e535253
initial commit
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sat, 01 Feb 2014 19:58:19 +0200 |
| parents | |
| children |
line source
1 /*
2 ---------------------------------------------------------------------------
3 Open Asset Import Library (assimp)
4 ---------------------------------------------------------------------------
6 Copyright (c) 2006-2012, assimp team
8 All rights reserved.
10 Redistribution and use of this software in source and binary forms,
11 with or without modification, are permitted provided that the following
12 conditions are met:
14 * Redistributions of source code must retain the above
15 copyright notice, this list of conditions and the
16 following disclaimer.
18 * Redistributions in binary form must reproduce the above
19 copyright notice, this list of conditions and the
20 following disclaimer in the documentation and/or other
21 materials provided with the distribution.
23 * Neither the name of the assimp team, nor the names of its
24 contributors may be used to endorse or promote products
25 derived from this software without specific prior
26 written permission of the assimp team.
28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 ---------------------------------------------------------------------------
40 */
42 /** @file assimp.hpp
43 * @brief Defines the C++-API to the Open Asset Import Library.
44 */
45 #ifndef INCLUDED_AI_ASSIMP_HPP
46 #define INCLUDED_AI_ASSIMP_HPP
48 #ifndef __cplusplus
49 # error This header requires C++ to be used. Use assimp.h for plain C.
50 #endif
52 // Public ASSIMP data structures
53 #include "types.h"
54 #include "config.h"
56 namespace Assimp {
57 // =======================================================================
58 // Public interface to Assimp
59 class Importer;
60 class Exporter; // export.hpp
61 class IOStream;
62 class IOSystem;
63 class ProgressHandler;
65 // =======================================================================
66 // Plugin development
67 //
68 // Include the following headers for the declarations:
69 // BaseImporter.h
70 // BaseProcess.h
71 class BaseImporter;
72 class BaseProcess;
73 class SharedPostProcessInfo;
74 class BatchLoader;
76 // =======================================================================
77 // Holy stuff, only for members of the high council of the Jedi.
78 class ImporterPimpl;
79 class ExporterPimpl; // export.hpp
80 } //! namespace Assimp
82 #define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff
84 struct aiScene;
86 // importerdesc.h
87 struct aiImporterDesc;
89 /** @namespace Assimp Assimp's CPP-API and all internal APIs */
90 namespace Assimp {
92 // ----------------------------------------------------------------------------------
93 /** CPP-API: The Importer class forms an C++ interface to the functionality of the
94 * Open Asset Import Library.
95 *
96 * Create an object of this class and call ReadFile() to import a file.
97 * If the import succeeds, the function returns a pointer to the imported data.
98 * The data remains property of the object, it is intended to be accessed
99 * read-only. The imported data will be destroyed along with the Importer
100 * object. If the import fails, ReadFile() returns a NULL pointer. In this
101 * case you can retrieve a human-readable error description be calling
102 * GetErrorString(). You can call ReadFile() multiple times with a single Importer
103 * instance. Actually, constructing Importer objects involves quite many
104 * allocations and may take some time, so it's better to reuse them as often as
105 * possible.
106 *
107 * If you need the Importer to do custom file handling to access the files,
108 * implement IOSystem and IOStream and supply an instance of your custom
109 * IOSystem implementation by calling SetIOHandler() before calling ReadFile().
110 * If you do not assign a custion IO handler, a default handler using the
111 * standard C++ IO logic will be used.
112 *
113 * @note One Importer instance is not thread-safe. If you use multiple
114 * threads for loading, each thread should maintain its own Importer instance.
115 */
116 class ASSIMP_API Importer {
118 public:
120 // -------------------------------------------------------------------
121 /** Constructor. Creates an empty importer object.
122 *
123 * Call ReadFile() to start the import process. The configuration
124 * property table is initially empty.
125 */
126 Importer();
128 // -------------------------------------------------------------------
129 /** Copy constructor.
130 *
131 * This copies the configuration properties of another Importer.
132 * If this Importer owns a scene it won't be copied.
133 * Call ReadFile() to start the import process.
134 */
135 Importer(const Importer& other);
137 // -------------------------------------------------------------------
138 /** Destructor. The object kept ownership of the imported data,
139 * which now will be destroyed along with the object.
140 */
141 ~Importer();
144 // -------------------------------------------------------------------
145 /** Registers a new loader.
146 *
147 * @param pImp Importer to be added. The Importer instance takes
148 * ownership of the pointer, so it will be automatically deleted
149 * with the Importer instance.
150 * @return AI_SUCCESS if the loader has been added. The registration
151 * fails if there is already a loader for a specific file extension.
152 */
153 aiReturn RegisterLoader(BaseImporter* pImp);
155 // -------------------------------------------------------------------
156 /** Unregisters a loader.
157 *
158 * @param pImp Importer to be unregistered.
159 * @return AI_SUCCESS if the loader has been removed. The function
160 * fails if the loader is currently in use (this could happen
161 * if the #Importer instance is used by more than one thread) or
162 * if it has not yet been registered.
163 */
164 aiReturn UnregisterLoader(BaseImporter* pImp);
166 // -------------------------------------------------------------------
167 /** Registers a new post-process step.
168 *
169 * At the moment, there's a small limitation: new post processing
170 * steps are added to end of the list, or in other words, executed
171 * last, after all built-in steps.
172 * @param pImp Post-process step to be added. The Importer instance
173 * takes ownership of the pointer, so it will be automatically
174 * deleted with the Importer instance.
175 * @return AI_SUCCESS if the step has been added correctly.
176 */
177 aiReturn RegisterPPStep(BaseProcess* pImp);
179 // -------------------------------------------------------------------
180 /** Unregisters a post-process step.
181 *
182 * @param pImp Step to be unregistered.
183 * @return AI_SUCCESS if the step has been removed. The function
184 * fails if the step is currently in use (this could happen
185 * if the #Importer instance is used by more than one thread) or
186 * if it has not yet been registered.
187 */
188 aiReturn UnregisterPPStep(BaseProcess* pImp);
191 // -------------------------------------------------------------------
192 /** Set an integer configuration property.
193 * @param szName Name of the property. All supported properties
194 * are defined in the aiConfig.g header (all constants share the
195 * prefix AI_CONFIG_XXX and are simple strings).
196 * @param iValue New value of the property
197 * @param bWasExisting Optional pointer to receive true if the
198 * property was set before. The new value replaces the previous value
199 * in this case.
200 * @note Property of different types (float, int, string ..) are kept
201 * on different stacks, so calling SetPropertyInteger() for a
202 * floating-point property has no effect - the loader will call
203 * GetPropertyFloat() to read the property, but it won't be there.
204 */
205 void SetPropertyInteger(const char* szName, int iValue,
206 bool* bWasExisting = NULL);
208 // -------------------------------------------------------------------
209 /** Set a boolean configuration property. Boolean properties
210 * are stored on the integer stack internally so it's possible
211 * to set them via #SetPropertyBool and query them with
212 * #GetPropertyBool and vice versa.
213 * @see SetPropertyInteger()
214 */
215 void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL) {
216 SetPropertyInteger(szName,value,bWasExisting);
217 }
219 // -------------------------------------------------------------------
220 /** Set a floating-point configuration property.
221 * @see SetPropertyInteger()
222 */
223 void SetPropertyFloat(const char* szName, float fValue,
224 bool* bWasExisting = NULL);
226 // -------------------------------------------------------------------
227 /** Set a string configuration property.
228 * @see SetPropertyInteger()
229 */
230 void SetPropertyString(const char* szName, const std::string& sValue,
231 bool* bWasExisting = NULL);
233 // -------------------------------------------------------------------
234 /** Get a configuration property.
235 * @param szName Name of the property. All supported properties
236 * are defined in the aiConfig.g header (all constants share the
237 * prefix AI_CONFIG_XXX).
238 * @param iErrorReturn Value that is returned if the property
239 * is not found.
240 * @return Current value of the property
241 * @note Property of different types (float, int, string ..) are kept
242 * on different lists, so calling SetPropertyInteger() for a
243 * floating-point property has no effect - the loader will call
244 * GetPropertyFloat() to read the property, but it won't be there.
245 */
246 int GetPropertyInteger(const char* szName,
247 int iErrorReturn = 0xffffffff) const;
249 // -------------------------------------------------------------------
250 /** Get a boolean configuration property. Boolean properties
251 * are stored on the integer stack internally so it's possible
252 * to set them via #SetPropertyBool and query them with
253 * #GetPropertyBool and vice versa.
254 * @see GetPropertyInteger()
255 */
256 bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
257 return GetPropertyInteger(szName,bErrorReturn)!=0;
258 }
260 // -------------------------------------------------------------------
261 /** Get a floating-point configuration property
262 * @see GetPropertyInteger()
263 */
264 float GetPropertyFloat(const char* szName,
265 float fErrorReturn = 10e10f) const;
267 // -------------------------------------------------------------------
268 /** Get a string configuration property
269 *
270 * The return value remains valid until the property is modified.
271 * @see GetPropertyInteger()
272 */
273 const std::string& GetPropertyString(const char* szName,
274 const std::string& sErrorReturn = "") const;
276 // -------------------------------------------------------------------
277 /** Supplies a custom IO handler to the importer to use to open and
278 * access files. If you need the importer to use custion IO logic to
279 * access the files, you need to provide a custom implementation of
280 * IOSystem and IOFile to the importer. Then create an instance of
281 * your custion IOSystem implementation and supply it by this function.
282 *
283 * The Importer takes ownership of the object and will destroy it
284 * afterwards. The previously assigned handler will be deleted.
285 * Pass NULL to take again ownership of your IOSystem and reset Assimp
286 * to use its default implementation.
287 *
288 * @param pIOHandler The IO handler to be used in all file accesses
289 * of the Importer.
290 */
291 void SetIOHandler( IOSystem* pIOHandler);
293 // -------------------------------------------------------------------
294 /** Retrieves the IO handler that is currently set.
295 * You can use #IsDefaultIOHandler() to check whether the returned
296 * interface is the default IO handler provided by ASSIMP. The default
297 * handler is active as long the application doesn't supply its own
298 * custom IO handler via #SetIOHandler().
299 * @return A valid IOSystem interface, never NULL.
300 */
301 IOSystem* GetIOHandler() const;
303 // -------------------------------------------------------------------
304 /** Checks whether a default IO handler is active
305 * A default handler is active as long the application doesn't
306 * supply its own custom IO handler via #SetIOHandler().
307 * @return true by default
308 */
309 bool IsDefaultIOHandler() const;
311 // -------------------------------------------------------------------
312 /** Supplies a custom progress handler to the importer. This
313 * interface exposes a #Update() callback, which is called
314 * more or less periodically (please don't sue us if it
315 * isn't as periodically as you'd like it to have ...).
316 * This can be used to implement progress bars and loading
317 * timeouts.
318 * @param pHandler Progress callback interface. Pass NULL to
319 * disable progress reporting.
320 * @note Progress handlers can be used to abort the loading
321 * at almost any time.*/
322 void SetProgressHandler ( ProgressHandler* pHandler );
324 // -------------------------------------------------------------------
325 /** Retrieves the progress handler that is currently set.
326 * You can use #IsDefaultProgressHandler() to check whether the returned
327 * interface is the default handler provided by ASSIMP. The default
328 * handler is active as long the application doesn't supply its own
329 * custom handler via #SetProgressHandler().
330 * @return A valid ProgressHandler interface, never NULL.
331 */
332 ProgressHandler* GetProgressHandler() const;
334 // -------------------------------------------------------------------
335 /** Checks whether a default progress handler is active
336 * A default handler is active as long the application doesn't
337 * supply its own custom progress handler via #SetProgressHandler().
338 * @return true by default
339 */
340 bool IsDefaultProgressHandler() const;
342 // -------------------------------------------------------------------
343 /** @brief Check whether a given set of postprocessing flags
344 * is supported.
345 *
346 * Some flags are mutually exclusive, others are probably
347 * not available because your excluded them from your
348 * Assimp builds. Calling this function is recommended if
349 * you're unsure.
350 *
351 * @param pFlags Bitwise combination of the aiPostProcess flags.
352 * @return true if this flag combination is fine.
353 */
354 bool ValidateFlags(unsigned int pFlags) const;
356 // -------------------------------------------------------------------
357 /** Reads the given file and returns its contents if successful.
358 *
359 * If the call succeeds, the contents of the file are returned as a
360 * pointer to an aiScene object. The returned data is intended to be
361 * read-only, the importer object keeps ownership of the data and will
362 * destroy it upon destruction. If the import fails, NULL is returned.
363 * A human-readable error description can be retrieved by calling
364 * GetErrorString(). The previous scene will be deleted during this call.
365 * @param pFile Path and filename to the file to be imported.
366 * @param pFlags Optional post processing steps to be executed after
367 * a successful import. Provide a bitwise combination of the
368 * #aiPostProcessSteps flags. If you wish to inspect the imported
369 * scene first in order to fine-tune your post-processing setup,
370 * consider to use #ApplyPostProcessing().
371 * @return A pointer to the imported data, NULL if the import failed.
372 * The pointer to the scene remains in possession of the Importer
373 * instance. Use GetOrphanedScene() to take ownership of it.
374 *
375 * @note Assimp is able to determine the file format of a file
376 * automatically.
377 */
378 const aiScene* ReadFile(
379 const char* pFile,
380 unsigned int pFlags);
382 // -------------------------------------------------------------------
383 /** Reads the given file from a memory buffer and returns its
384 * contents if successful.
385 *
386 * If the call succeeds, the contents of the file are returned as a
387 * pointer to an aiScene object. The returned data is intended to be
388 * read-only, the importer object keeps ownership of the data and will
389 * destroy it upon destruction. If the import fails, NULL is returned.
390 * A human-readable error description can be retrieved by calling
391 * GetErrorString(). The previous scene will be deleted during this call.
392 * Calling this method doesn't affect the active IOSystem.
393 * @param pBuffer Pointer to the file data
394 * @param pLength Length of pBuffer, in bytes
395 * @param pFlags Optional post processing steps to be executed after
396 * a successful import. Provide a bitwise combination of the
397 * #aiPostProcessSteps flags. If you wish to inspect the imported
398 * scene first in order to fine-tune your post-processing setup,
399 * consider to use #ApplyPostProcessing().
400 * @param pHint An additional hint to the library. If this is a non
401 * empty string, the library looks for a loader to support
402 * the file extension specified by pHint and passes the file to
403 * the first matching loader. If this loader is unable to completely
404 * the request, the library continues and tries to determine the
405 * file format on its own, a task that may or may not be successful.
406 * Check the return value, and you'll know ...
407 * @return A pointer to the imported data, NULL if the import failed.
408 * The pointer to the scene remains in possession of the Importer
409 * instance. Use GetOrphanedScene() to take ownership of it.
410 *
411 * @note This is a straightforward way to decode models from memory
412 * buffers, but it doesn't handle model formats that spread their
413 * data across multiple files or even directories. Examples include
414 * OBJ or MD3, which outsource parts of their material info into
415 * external scripts. If you need full functionality, provide
416 * a custom IOSystem to make Assimp find these files and use
417 * the regular ReadFile() API.
418 */
419 const aiScene* ReadFileFromMemory(
420 const void* pBuffer,
421 size_t pLength,
422 unsigned int pFlags,
423 const char* pHint = "");
425 // -------------------------------------------------------------------
426 /** Apply post-processing to an already-imported scene.
427 *
428 * This is strictly equivalent to calling #ReadFile() with the same
429 * flags. However, you can use this separate function to inspect
430 * the imported scene first to fine-tune your post-processing setup.
431 * @param pFlags Provide a bitwise combination of the
432 * #aiPostProcessSteps flags.
433 * @return A pointer to the post-processed data. This is still the
434 * same as the pointer returned by #ReadFile(). However, if
435 * post-processing fails, the scene could now be NULL.
436 * That's quite a rare case, post processing steps are not really
437 * designed to 'fail'. To be exact, the #aiProcess_ValidateDS
438 * flag is currently the only post processing step which can actually
439 * cause the scene to be reset to NULL.
440 *
441 * @note The method does nothing if no scene is currently bound
442 * to the #Importer instance. */
443 const aiScene* ApplyPostProcessing(unsigned int pFlags);
445 // -------------------------------------------------------------------
446 /** @brief Reads the given file and returns its contents if successful.
447 *
448 * This function is provided for backward compatibility.
449 * See the const char* version for detailled docs.
450 * @see ReadFile(const char*, pFlags) */
451 const aiScene* ReadFile(
452 const std::string& pFile,
453 unsigned int pFlags);
455 // -------------------------------------------------------------------
456 /** Frees the current scene.
457 *
458 * The function does nothing if no scene has previously been
459 * read via ReadFile(). FreeScene() is called automatically by the
460 * destructor and ReadFile() itself. */
461 void FreeScene( );
463 // -------------------------------------------------------------------
464 /** Returns an error description of an error that occurred in ReadFile().
465 *
466 * Returns an empty string if no error occurred.
467 * @return A description of the last error, an empty string if no
468 * error occurred. The string is never NULL.
469 *
470 * @note The returned function remains valid until one of the
471 * following methods is called: #ReadFile(), #FreeScene(). */
472 const char* GetErrorString() const;
474 // -------------------------------------------------------------------
475 /** Returns the scene loaded by the last successful call to ReadFile()
476 *
477 * @return Current scene or NULL if there is currently no scene loaded */
478 const aiScene* GetScene() const;
480 // -------------------------------------------------------------------
481 /** Returns the scene loaded by the last successful call to ReadFile()
482 * and releases the scene from the ownership of the Importer
483 * instance. The application is now responsible for deleting the
484 * scene. Any further calls to GetScene() or GetOrphanedScene()
485 * will return NULL - until a new scene has been loaded via ReadFile().
486 *
487 * @return Current scene or NULL if there is currently no scene loaded
488 * @note Use this method with maximal caution, and only if you have to.
489 * By design, aiScene's are exclusively maintained, allocated and
490 * deallocated by Assimp and no one else. The reasoning behind this
491 * is the golden rule that deallocations should always be done
492 * by the module that did the original allocation because heaps
493 * are not necessarily shared. GetOrphanedScene() enforces you
494 * to delete the returned scene by yourself, but this will only
495 * be fine if and only if you're using the same heap as assimp.
496 * On Windows, it's typically fine provided everything is linked
497 * against the multithreaded-dll version of the runtime library.
498 * It will work as well for static linkage with Assimp.*/
499 aiScene* GetOrphanedScene();
504 // -------------------------------------------------------------------
505 /** Returns whether a given file extension is supported by ASSIMP.
506 *
507 * @param szExtension Extension to be checked.
508 * Must include a trailing dot '.'. Example: ".3ds", ".md3".
509 * Cases-insensitive.
510 * @return true if the extension is supported, false otherwise */
511 bool IsExtensionSupported(const char* szExtension) const;
513 // -------------------------------------------------------------------
514 /** @brief Returns whether a given file extension is supported by ASSIMP.
515 *
516 * This function is provided for backward compatibility.
517 * See the const char* version for detailed and up-to-date docs.
518 * @see IsExtensionSupported(const char*) */
519 inline bool IsExtensionSupported(const std::string& szExtension) const;
521 // -------------------------------------------------------------------
522 /** Get a full list of all file extensions supported by ASSIMP.
523 *
524 * If a file extension is contained in the list this does of course not
525 * mean that ASSIMP is able to load all files with this extension ---
526 * it simply means there is an importer loaded which claims to handle
527 * files with this file extension.
528 * @param szOut String to receive the extension list.
529 * Format of the list: "*.3ds;*.obj;*.dae". This is useful for
530 * use with the WinAPI call GetOpenFileName(Ex). */
531 void GetExtensionList(aiString& szOut) const;
533 // -------------------------------------------------------------------
534 /** @brief Get a full list of all file extensions supported by ASSIMP.
535 *
536 * This function is provided for backward compatibility.
537 * See the aiString version for detailed and up-to-date docs.
538 * @see GetExtensionList(aiString&)*/
539 inline void GetExtensionList(std::string& szOut) const;
541 // -------------------------------------------------------------------
542 /** Get the number of importrs currently registered with Assimp. */
543 size_t GetImporterCount() const;
545 // -------------------------------------------------------------------
546 /** Get meta data for the importer corresponding to a specific index..
547 *
548 * For the declaration of #aiImporterDesc, include <assimp/importerdesc.h>.
549 * @param index Index to query, must be within [0,GetImporterCount())
550 * @return Importer meta data structure, NULL if the index does not
551 * exist or if the importer doesn't offer meta information (
552 * importers may do this at the cost of being hated by their peers).*/
553 const aiImporterDesc* GetImporterInfo(size_t index) const;
555 // -------------------------------------------------------------------
556 /** Find the importer corresponding to a specific index.
557 *
558 * @param index Index to query, must be within [0,GetImporterCount())
559 * @return Importer instance. NULL if the index does not
560 * exist. */
561 BaseImporter* GetImporter(size_t index) const;
563 // -------------------------------------------------------------------
564 /** Find the importer corresponding to a specific file extension.
565 *
566 * This is quite similar to #IsExtensionSupported except a
567 * BaseImporter instance is returned.
568 * @param szExtension Extension to check for. The following formats
569 * are recognized (BAH being the file extension): "BAH" (comparison
570 * is case-insensitive), ".bah", "*.bah" (wild card and dot
571 * characters at the beginning of the extension are skipped).
572 * @return NULL if no importer is found*/
573 BaseImporter* GetImporter (const char* szExtension) const;
575 // -------------------------------------------------------------------
576 /** Find the importer index corresponding to a specific file extension.
577 *
578 * @param szExtension Extension to check for. The following formats
579 * are recognized (BAH being the file extension): "BAH" (comparison
580 * is case-insensitive), ".bah", "*.bah" (wild card and dot
581 * characters at the beginning of the extension are skipped).
582 * @return (size_t)-1 if no importer is found */
583 size_t GetImporterIndex (const char* szExtension) const;
588 // -------------------------------------------------------------------
589 /** Returns the storage allocated by ASSIMP to hold the scene data
590 * in memory.
591 *
592 * This refers to the currently loaded file, see #ReadFile().
593 * @param in Data structure to be filled.
594 * @note The returned memory statistics refer to the actual
595 * size of the use data of the aiScene. Heap-related overhead
596 * is (naturally) not included.*/
597 void GetMemoryRequirements(aiMemoryInfo& in) const;
599 // -------------------------------------------------------------------
600 /** Enables "extra verbose" mode.
601 *
602 * 'Extra verbose' means the data structure is validated after *every*
603 * single post processing step to make sure everyone modifies the data
604 * structure in a well-defined manner. This is a debug feature and not
605 * intended for use in production environments. */
606 void SetExtraVerbose(bool bDo);
609 // -------------------------------------------------------------------
610 /** Private, do not use. */
611 ImporterPimpl* Pimpl() { return pimpl; };
612 const ImporterPimpl* Pimpl() const { return pimpl; };
614 protected:
616 // Just because we don't want you to know how we're hacking around.
617 ImporterPimpl* pimpl;
618 }; //! class Importer
621 // ----------------------------------------------------------------------------
622 // For compatibility, the interface of some functions taking a std::string was
623 // changed to const char* to avoid crashes between binary incompatible STL
624 // versions. This code her is inlined, so it shouldn't cause any problems.
625 // ----------------------------------------------------------------------------
627 // ----------------------------------------------------------------------------
628 AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){
629 return ReadFile(pFile.c_str(),pFlags);
630 }
631 // ----------------------------------------------------------------------------
632 AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const {
633 aiString s;
634 GetExtensionList(s);
635 szOut = s.data;
636 }
637 // ----------------------------------------------------------------------------
638 AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const {
639 return IsExtensionSupported(szExtension.c_str());
640 }
642 } // !namespace Assimp
643 #endif // INCLUDED_AI_ASSIMP_HPP