Assimp-News

[kimmi]

Habe gerade erst bemerkt, dass man zur Teilnahme bei Patreon angemeldet sein muß. Ich werde das Ganze mal auf der Website starten.

[Krishty]

C4D importiert mit falscher Orientierung.

Soweit ich das sehen kann, ist bei C4D X rechts, Y hoch, und Z in den Bildschirm hinein (left-handed). Die Dateidaten werden aber ohne Konvertierung nach Assimp übertragen und dort als right-handed behandelt.

Nachtrag: mein “fix” in void C4DImporter::InternReadFile:

    pScene->mRootNode = new aiNode("<C4DRoot>");
⇨   pScene->mRootNode->mTransformation.c3 = -1.0f; // transform left-handed to right-handed

… ich weiß aber gar nicht, ob Y/Z nicht auch getauscht werden müssen und wie das mit Texturen läuft usw. usf. Habe auch kein Cinema4D zum Testen hier. Ihr könnt das also sicher besser …

[Krishty]

Der Blender-Import interpretiert das Koordinatensystem falsch, oder? Von 20 Blender-Dateien, die ich stichprobenartig herausgesucht habe, war bei 15 offensichtlich Z oben statt Y. Beim Rest hätte man drüber streiten können, wie es der Künstler ausgelegt hat.

[kimmi]

Hatte ich gar nicht mehr auf dem Zettel, aber da war was, ja. Danke für den Hinweis! Mal sehen, ob ich das bald beheben kann.

Momentan versuche ich noch aus dem FBX-Transformationen schlau zu werden.

[Krishty]

FBX ist selten, oder? Seit letzter Woche crawle ich thingiverse, und unter den rund 320.000 Modellen, die ich bisher habe, waren vier FBX (dreimal binär, einmal Text). Die laden so weit ganz ordentlich.

Falls es dir hilft: Visual Studio kann ebenfalls FBX importieren; ich würde Microsoft zutrauen, die Referenzimplementierung lizensiert zu haben.

Nachtrag: Ja, unter Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\Extensions\Microsoft\VsGraphics liegt eine libfbxsdk.dll von Autodesk. Kannst also im Zweifel mit Visual Studio vergleichen.

————

X3D geht nicht, sobald Texturen drin sind. Attribute "url" in node <ImageTexture> has incorrect value. sobald eine Datei das hier enthält:

Code: Alles auswählen

<?xml version='1.0' encoding='UTF-8'?>
	<X3D profile="Immersive" version="3.1">
	<Scene>
		<Shape>
			<Appearance>
				<ImageTexture url='texture.png'/>
			</Appearance>
		</Shape>
	</Scene>
</X3D>

Ich habe gerade nicht die Spezifikation parat um zu prüfen, ob das korrekt ist; aber es kommt häufig vor und FreeWRL (gammeligster X3D-Loader der Welt) lädt es.

[kimmi]

FBX wird oft angefragt. Und wenn ich hauptberuflich Assimp machen würde, wären die ganzen Bugs auch kein Problem :). Danke für den Bug-Report, das schaue ich mir auch mal an.

ich habe angefangen, unter https://www.patreon.com/assimp einen monatlichen Rückblick auf die Höhepunkte des aktuellen Masters zu schreiben.

Für August sieht das so aus: https://www.patreon.com/posts/asset-importer-14214732

Wenn Ihr Feedback für mich habt, nur zu.

[kimmi]

den 3D-Printer von thingiverse kenne ich :) ...

[Krishty]

den 3D-Printer von thingiverse kenne ich :) ...

Welchen?

[kimmi]

Den, den wir hier haben. Kenne den genauen Typen gar nicht.

[Krishty]

Ach ja, sie gehören zu MakerBot. Hat mit den Modellen dort aber nicht viel zu tun.

[kimmi]

Ich weiß, war mir beim Besuch der Website nur gerade aufgefallen. FBX wird in dem Umfeld auf wenig benutzt. Aber beim Import von Modellern wird es öfter verwendet.

[kimmi]

glFT2.0-Import und Export ist auf dem aktuellem Master: https://www.patreon.com/posts/14395686

Freuen uns über jegliche Form von Feedback. Dazu schlage ich mich noch immer mit FBX rum.

[Thoran]

Mal abgesehen davon, dass FBX eine API-Hölle ist, was ist Dein konkretes Problem?

[kimmi]

Dass das Kurbelwellenproblem noch besteht. Die Welle wird nicht richtig platziert, da ich die Connnections der jeweiligen FBXNodes korrekt auslesen muss. Und das habe ich zwar auf meinem Stapel zu erledigender probleme, aber noch nicht angegangen.

[Krishty]

Diese Änderung in SIBImporter.cpp ist mir aufgefallen, Zeilen 187–204:

  std::vector<unsigned char> str;
  str.reserve(numWChars * 4 + 1);

…

  utf8::utf16to8(start, end, back_inserter(str));

…

  str[str.size()] = '\0'; // !!!
  aiString result = aiString((const char *)&str[0]);

Das stinkt zum Himmel. Es könnte durch ein Schlupfloch sein, dass man hinter die Größe eines std::vector schreiben/lesen darf, so lange er ausreichend groß reserviert ist … aber ich würde mich auf keinen Fall darauf verlassen und das sollte in jedem Review erneut die Sirenen aufheulen lassen.

Könnt ihr aiString keinen Konstruktor mit begin und end statt Nullterminierung verpassen, um die Situation zu entschärfen? Mit std::string würde ich an der Stelle auch einfach std::string result(str.begin(), str.end()); schreiben, anstatt Nullen in dunkle Bereiche von Arrays zu schieben …

… oder ändert es zumindest zu str.push_back('\0'); … und zu str.data() statt &str[0] …

… und das Speicherleck bei Exceptions durch die umliegenden new/delete sollte auch deutlich sein.

(Ich meckere normalerweise nicht über sowas, aber der Code wurde frisch geändert – und wenn man ihn schon ändert, dann bitte richtig™. Mit *jeder* STL löst der Code sofort eine Assertion aus; das bedeutet, dass der Autor vor dem Hochladen kein einziges Mal einen Debug Build kompiliert hat.)

[Krishty]

Gut:
Der 3MF-Bug mit Post Processing Order ist behoben.

Schlecht:
3DS scheint falsche Transformation zu haben, wenn Objekte gespiegelt sind. Die entsprechenden Datei kommt direkt aus 3ds Max; ich schicke sie dir via PM.

Noch schlechter:
Bei FBX sind die Transformationsfehler noch extremer. Außerdem kommen die Farben zu dunkel raus – habt ihr in Assimps Materialeigenschaften ein Flag für sRGB/linear oder einen Gamma-Faktor, den ich übersehe?

[Chromanoid]

Habt ihr mal überlegt automatische Tests mit Bildvergleich einzubauen? Also Soll-Bild vs. tatsächliche Ausgabe (z.B. via https://github.com/donbright/diffpng)? Dann würde man solche Fehler ziemlich schnell sehen und man muss nicht komplizierte Vertex-Prüfungen machen. Oder macht ihr die Tests so schon?

BTW ich weiß das geht da vielleicht eher unter, aber irgendwie verstehe ich nicht warum Assimp-News in der Kategorie "Autorensysteme und Toolkits" gelandet ist. Wahrscheinlich wegen Toolkit oder? Ich glaube damit waren eher Toolkits für komplette Spiele gemeint...

[Krishty]

Das Problem ist eher, dass zu wenige Testdateien vorliegen. 80 % der Dateien im Netz nutzen nur 20 % der Features und sind leicht korrekt darzustellen.

Die restlichen 20 % der Dateien sind dafür höllische Verkettungen von Sonderfällen. Sowas zu finden ist schwer genug, aber dann noch mit passender Lizenz …

… die Testdateien, die ich kimmi schicke, stammen auch von unseren Kunden und dürfen auf keinen Fall im offiziellen Repository landen. Um die nachzubauen, muss er sich wahrscheinlich erstmal 3ds Max besorgen und nachmachen, was bei der Originaldatei gemacht wurde (spezieller Objekttyp, via spezieller Option spiegeln, etc).

Ich habe in meinem VRML-Import ungefähr 80 % Code-Abdeckung, bei 200 isolierten Testfällen und 10.000(!) heruntergeladenen Testdateien. Auf Github würden nur die 200 isolierten Testfälle landen, weil ich für den Rest niemals die Lizenzen klären könnte. So schlimm ist das.

————

Übrigens braucht man auch kein diffpng für sowas. Ich habe alle meine Testfälle so ausgelegt, dass der Pixel in der Mitte nur bei Erfolg grün ist. Rate mal, welcher Testfall hier nicht funktioniert:

[kimmi]

Das Ding mit dem SIB schaue ich mir an, riecht in der Tat komisch. Ist mir beim Review durch ie Lappen gegangen. Ebenfalls komisch: Clangs AddressSanitizer und MemorySanitizer schlagen nicht an. Das kann aber auch in der Tatsache begründet sein, dass wir keinen Testfall dafür haben :o).

Danke auf jeden Fall für den Hinweis.

[kimmi]

Bitmap-Vergleiche würden gehen, ich habe aber einen Scene-Differ gebaut. Bei Bildern hat man schnell sehr viele Daten, die man mittels git sehr schwer verwalten kann ( Diffs und so ). Da steckt richtig Arbeit drinn. Und da das Ganze in der Freizeit läuft, geht halt nicht alles.

Dewegen verweise ich noch mal auf unsere PAtreon-Seite *hüstel*: https://www.patreon.com/assimp

[kimmi]

Und ich habe in den letzten Tagen mehr als 10 Issues zumachen können. Der Assimp-Build für Android wird gerade schön gemacht und ich arbeite Altlasten ( FBX z.B. ) ab.

Der CI-Build testet nun auch auf Zugriffsverletzungen und Memory-Leaks ( Clang sei Dank ) und ist bedeutend schneller geworden. FBX und IFC entwickeln sich zu immer größeren Baustellen. Allein der Umfang / KOmplexitität der Importer haut mich jedes mal wieder um.

[Krishty]

Bei Bildern hat man schnell sehr viele Daten, die man mittels git sehr schwer verwalten kann ( Diffs und so ).

… und ein weiterer Nachteil: Falls man mal die Beleuchtungsbedingungen ändert (weil man z.B. gemerkt hat, dass der Shader das Licht nicht sRGB-korrekt gerendert hat), muss man *alle* Testbilder von Hand neu verifizieren. Dein Szenen-Vergleich ist da sicher der viel bessere Weg.

Dewegen verweise ich noch mal auf unsere PAtreon-Seite *hüstel*: https://www.patreon.com/assimp

Ja; ich kann’s mir nur gerade nicht leisten. Vielleicht kriege ich das über die Firma hin, dass wir vorrangige Behandlung kaufen.

FBX und IFC entwickeln sich zu immer größeren Baustellen. Allein der Umfang / KOmplexitität der Importer haut mich jedes mal wieder um.

Ich wundere mich noch immer, wie ihr COLLADA geschafft habt. Das unterstützt doch auch 1000 Dinge, bis hin zu Physiksimulation … Schulterklopfen dafür.

[kimmi]

Das war Schrompf und Alexander! Da ziehe ich auch den Hut vor.

[Chromanoid]

Bitmap-Vergleiche würden gehen, ich habe aber einen Scene-Differ gebaut. Bei Bildern hat man schnell sehr viele Daten, die man mittels git sehr schwer verwalten kann ( Diffs und so ). Da steckt richtig Arbeit drinn. Und da das Ganze in der Freizeit läuft, geht halt nicht alles.

Ah verstehe. Ich dachte ehrlich gesagt daran, dass man die gleiche Szene in allen Formaten bereitstellt und dann nur eine Referenz-Bilderserie (für unterschiedliche Perspektiven und Features) benötigt. Das Bereitstellen der Referenzbilder müsste natürlich auch automatisch gehen, dann muss man nichts verwalten, nur ab und zu den Referenz-Bild-Generator anwerfen, wenn man so eine Situation hat, die Krishty beschreibt. Aber ein Szene-Differ ist doch auch gut.

Übrigens braucht man auch kein diffpng für sowas. Ich habe alle meine Testfälle so ausgelegt, dass der Pixel in der Mitte nur bei Erfolg grün ist.

Cool. Ich frage mich wie das möglich ist, wenn man wirklich Material-Render-Regressionstests machen möchte.

[kimmi]

Für alle 3D-Druck-Leute hier: der 3MF-Exporter ist auf master als Experimental.

Gruß Kimmi

[kimmi]

Habe gerade Version 4.1.0 der Asset-Importer-Lib released, um die Mengen an Fixes und neuen Features unters Volk zu bekommen.
Einige Highlights:

• glFT2 import und Export
• 3DF-Exporter
• Statische Code-Analyse im CI Build
• CI benutzt den Adress Sanitizer von Clang
• Verbesserungen im Build-Support für Android
• ...

Release-Notes können hier eingesehen werden: https://github.com/assimp/assimp/releases/tag/v4.1.0

Viel Spass damit!

[kimmi]

Wir haben unser erstes Asset-Importer-Lib auf Patreon ( siehe https://www.patreon.com/assimp ) geknackt. Somit werden in den nächsten Wochen automatisch Windows-Installer per CI-Build zur Verfügung gestellt werden. Ich war mir gar nicht so sicher, ob die Patreon-Plattform für einer Lib wie Assimp irgendwelche Unterstützung bieten wird. Um so positiver bin ich davon überrrascht, dass mich so viele bei der Arbeit unterstützen wollen :).

Die zwischenzeitliche Missetat der Patreon-CEO's, die Patronen für ihr Engangement stärker zur Kasse zu bitten, wurde übrigens rückgängig gemacht. Das hat für viel Ärger gesorgt.

Viele Grüße,
Kim

[Krishty]

kimmi, habt ihr diesen Commit getestet? https://github.com/assimp/assimp/commit ... 284ccccac5

Ich hab’s nicht und weiß jetzt nicht, ob das

• bloß eine Warnung behebt (wie im Titel steht) und das ++ überflüssig war,
• oder ob das ++ versehentlich gelöscht wurde und nun der Importer Schrott ist.

————

Außerdem muss in C4DImporter.cpp (80) das hier:

Code: Alles auswählen

namespace Assimp {
    template<> const std::string LogFunctions<C4DImporter>::log_prefix = "C4D: ";
}

durch das ersetzt werden:

Code: Alles auswählen

namespace Assimp {
    template<> const char* LogFunctions<C4DImporter>::Prefix()
    {
        static auto prefix = "C4D: ";
        return prefix;
    }
}

… wahrscheinlich kompiliert ihr ohne C4D-Unterstützung, dann fällt euch sowas nicht auf.


————

P.S.: Warum eigentlich static auto prefix = "C4D: "; return prefix; anstatt return "C4D: ";? Das sieht mir völlig verkompliziert aus. Ist das eine Optimierung aus der Zeit, als das noch ein std::string war?

Und … warum eigentlich eine Funktion statt einer Variable? Hat da jemand das überflüssige-Singletons-Fieber gekriegt? In der ursprünglichen Fassung den std::string durch char const * zu ersetzen wäre das allerkürzeste, deutlichste gewesen …

[Krishty]

Übrigens habe ich hier noch ein paar synthetische STL-Tests für meinen Viewer herumliegen, die du in Assimps Testmatrix integrieren kannst. Ich weiß gerade nicht, wie der Stand bei euch ist, darum melde dich einfach, falls Bedarf besteht :)

[Krishty]

Gehe ich recht in der Annahme, dass IFCReaderGen_4.cpp experimentell ist und man nicht erwarten kann, dass er kompiliert?


Ich find’s schön, dass ihr langsam alles zu std::unique_ptr und std::shared_ptr portiert, aber bitte initialisiert dann auch richtig! Hier sind 77 Stellen, die durch make_unique oder make_shared ersetzt werden sollten:

Code: Alles auswählen

code\3DSConverter.cpp(366):        std::unique_ptr< std::vector<unsigned int>[] > aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
code\AMFImporter.cpp(413):	std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
code\B3DImporter.cpp(313):        std::unique_ptr<aiMaterial> mat(new aiMaterial);
code\B3DImporter.cpp(404):    std::unique_ptr<aiMesh> mesh(new aiMesh);
code\B3DImporter.cpp(519):    std::unique_ptr<aiAnimation> anim(new aiAnimation);
code\B3DImporter.cpp(710):        _materials.emplace_back( std::unique_ptr<aiMaterial>(new aiMaterial) );
code\BlenderDNA.h(338):        out = std::shared_ptr<T>(new T());
code\BlenderDNA.inl(91):    return std::shared_ptr<T>(new T());
code\BlenderDNA.inl(387):    out =  std::shared_ptr< FileOffset > (new FileOffset());
code\BlenderLoader.cpp(194):        std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
code\BlenderLoader.cpp(267):    out.reader = std::shared_ptr<StreamReaderAny>(new StreamReaderAny(stream,out.little));
code\BlenderLoader.cpp(569):                std::shared_ptr<Material> p(new Material());
code\BlenderLoader.cpp(1143):    std::unique_ptr<aiCamera> out(new aiCamera());
code\BlenderLoader.cpp(1160):    std::unique_ptr<aiLight> out(new aiLight());
code\BlenderLoader.cpp(1216):    std::unique_ptr<aiNode> node(new aiNode(obj->id.name+2)); // skip over the name prefix 'OB'
code\BlenderModifier.cpp(318):    std::unique_ptr<aiMesh*[]> tempmeshes(new aiMesh*[out.mNumMeshes]());
code\C4DImporter.cpp(192):            std::unique_ptr<aiMaterial> def_material(new aiMaterial());
code\C4DImporter.cpp(414):    std::unique_ptr<aiMesh> mesh(new aiMesh());
code\COBLoader.cpp(145):    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
code\COBLoader.cpp(212):    std::unique_ptr<Node> root(new Group());
code\COBLoader.cpp(677):    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
code\COBLoader.cpp(733):    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
code\COBLoader.cpp(751):    out.nodes.push_back(std::shared_ptr<Bone>(new Bone()));
code\COBLoader.cpp(767):    out.nodes.push_back(std::shared_ptr<Group>(new Group()));
code\COBLoader.cpp(781):    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
code\COBLoader.cpp(1039):    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
code\COBLoader.cpp(1229):    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
code\COBLoader.cpp(1252):    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
code\COBLoader.cpp(1268):    out.nodes.push_back(std::shared_ptr<Group>(new Group()));
code\ColladaParser.cpp(100):    std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
code\CSMLoader.cpp(139):    std::unique_ptr<aiAnimation> anim(new aiAnimation());
code\D3MFImporter.cpp(130):        std::unique_ptr<aiNode> node(new aiNode());
code\D3MFImporter.cpp(438):    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
code\D3MFOpcPackage.cpp(512):    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(stream));
code\DXFLoader.cpp(379):            std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
code\FIReader.cpp(1808):    std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
code\FIReader.cpp(1823):        return std::unique_ptr<FIReader>(new CFIReaderImpl(std::move(data), size));
code\FIReader.cpp(1826):        auto memios = std::unique_ptr<MemoryIOStream>(new MemoryIOStream(data.release(), size, true));
code\FIReader.cpp(1827):        auto callback = std::unique_ptr<CIrrXML_IOStreamReader>(new CIrrXML_IOStreamReader(memios.get()));
code\FIReader.cpp(1828):        return std::unique_ptr<FIReader>(new CXMLReaderImpl(std::unique_ptr<irr::io::IIrrXMLReader<char, irr::io::IXMLBase>>(createIrrXMLReader(callback.get()))));
code\Importer\IFC\IFCBoolean.cpp(413):    std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
code\Importer\IFC\IFCBoolean.cpp(730):    std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
code\Importer\IFC\IFCGeometry.cpp(663):        std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
code\Importer\IFC\IFCGeometry.cpp(666):        std::shared_ptr<TempMesh> profile2D = std::shared_ptr<TempMesh>(new TempMesh());
code\Importer\IFC\IFCLoader.cpp(426):    std::unique_ptr<aiNode> nd(new aiNode());
code\Importer\IFC\IFCLoader.cpp(684):    std::unique_ptr<aiNode> nd(new aiNode());
code\Importer\IFC\IFCLoader.cpp(767):                    std::unique_ptr<aiNode> nd_aggr(new aiNode());
code\Importer\IFC\IFCLoader.cpp(812):                std::unique_ptr<aiNode> nd_aggr(new aiNode());
code\Importer\IFC\IFCMaterial.cpp(151):                        std::unique_ptr<aiMaterial> mat(new aiMaterial());
code\Importer\IFC\IFCMaterial.cpp(189):    std::unique_ptr<aiMaterial> mat(new aiMaterial());
code\Importer\IFC\IFCUtil.cpp(80):    std::unique_ptr<aiMesh> mesh(new aiMesh());
code\LWOLoader.cpp(1128):        std::unique_ptr<float[]> temp(new float[type]);
code\MMDCpp14.h(68):            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
code\MMDCpp14.h(75):            return std::unique_ptr<T>(new U[n]());
code\MMDImporter.cpp(171):  std::unique_ptr<aiNode *[]> ppNode(new aiNode *[pModel->bone_count]);
code\ObjFileImporter.cpp(325):    std::unique_ptr<aiMesh> pMesh(new aiMesh);
code\OgreImporter.cpp(130):        std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(scopedFile.get()));
code\OgreXmlSerializer.cpp(750):    std::unique_ptr<CIrrXML_IOStreamReader> stream(new CIrrXML_IOStreamReader(file.get()));
code\STEPFile.h(510):            std::unique_ptr<TDerived> impl(new TDerived());
code\Importer\IFC\STEPFileEncoding.cpp(357):                            std::unique_ptr<uint16_t[]> src(new uint16_t[count]);
code\Importer\IFC\STEPFileEncoding.cpp(366):                            std::unique_ptr<unsigned char[]> dest(new unsigned char[dcount]);
code\Importer\IFC\STEPFileEncoding.cpp(388):                            std::unique_ptr<uint32_t[]> src(new uint32_t[count]);
code\Importer\IFC\STEPFileEncoding.cpp(399):                            std::unique_ptr<unsigned char[]> dest(new unsigned char[dcount]);
code\Importer\IFC\STEPFileReader.cpp(92):    std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
code\Importer\IFC\STEPFileReader.cpp(93):    std::unique_ptr<STEP::DB> db = std::unique_ptr<STEP::DB>(new STEP::DB(reader));
code\XGLLoader.cpp(163):        std::unique_ptr<StreamReaderLE> raw_reader(new StreamReaderLE(stream));
code\XGLLoader.cpp(352):    std::unique_ptr<aiLight> l(new aiLight());
code\XGLLoader.cpp(373):    std::unique_ptr<aiNode> nd(new aiNode());
code\XGLLoader.cpp(532):    std::unique_ptr<aiMesh> mesh(new aiMesh());
code\XGLLoader.cpp(738):    std::unique_ptr<aiMaterial> mat(new aiMaterial());
code\BaseImporter.cpp(93):    std::unique_ptr<aiScene> sc(new aiScene());
code\BaseImporter.cpp(158):        std::unique_ptr<char[]> _buffer (new char[searchBytes+1 /* for the '\0' */]);
code\FindInstancesProcess.cpp(131):        std::unique_ptr<uint64_t[]> hashes (new uint64_t[pScene->mNumMeshes]);
code\FindInstancesProcess.cpp(132):        std::unique_ptr<unsigned int[]> remapping (new unsigned int[pScene->mNumMeshes]);
code\FindInstancesProcess.cpp(224):                        std::unique_ptr<unsigned int[]> ftbl_orig(new unsigned int[orig->mNumVertices]);
code\FindInstancesProcess.cpp(225):                        std::unique_ptr<unsigned int[]> ftbl_inst(new unsigned int[orig->mNumVertices]);
code\TriangulateProcess.cpp(197):    std::unique_ptr<bool[]> done(new bool[max_out]);

bool exist( false );
if(it != m_ArchiveMap.end()) {
exist = true;
}
return exist;

*zoom.jpg*
Wie wär’s mit

return it != m_ArchiveMap.end();

In Importer.cpp (192) habt ihr auch einen Rechtschreibfehler durch einen anderen ersetzt.