Merge branch 'master' of https://github.com/assimp/assimp

CodeConventions.txt

@@ -0,0 +1,14 @@
+       ===============================================
+        The Asset-Importer-Library Coding conventions
+       ===============================================
+
+	If you want to participate to the Asset-Importer_Library please have a look
+	onto these coding conventions and try to follow them. They are more or less
+	some kind of guide line to help others coming into the code and help all
+	the Asset-Importer-Library users.
+	
+	 Tab width
+	===========
+	The tab width shall be 4 spaces.
+	
+	

code/Exporter.cpp

@@ -60,6 +60,7 @@ Here we implement only the C++ interface (Assimp::Exporter).
 #include "BaseProcess.h" 
 #include "Importer.h" // need this for GetPostProcessingStepInstanceList()
 
+#include "JoinVerticesProcess.h"
 #include "MakeVerboseFormat.h"
 #include "ConvertToLHProcess.h"
 
@@ -73,6 +74,7 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
 void ExportSceneCollada(const char*,IOSystem*, const aiScene*);
 void ExportSceneObj(const char*,IOSystem*, const aiScene*);
 void ExportSceneSTL(const char*,IOSystem*, const aiScene*);
+void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*);
 void ExportScenePly(const char*,IOSystem*, const aiScene*);
 void ExportScene3DS(const char*, IOSystem*, const aiScene*) {}
 
@@ -86,13 +88,16 @@ Exporter::ExportFormatEntry gExporters[] =
 
 #ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
 	Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj, 
-		aiProcess_GenNormals | aiProcess_PreTransformVertices),
+		aiProcess_GenNormals /*| aiProcess_PreTransformVertices */),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_STL_EXPORTER
 	Exporter::ExportFormatEntry( "stl", "Stereolithography", "stl" , &ExportSceneSTL, 
 		aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
 	),
+	Exporter::ExportFormatEntry( "stlb", "Stereolithography(binary)", "stlb" , &ExportSceneSTLBinary, 
+		aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
+	),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
@@ -260,6 +265,7 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
 
 				// If the input scene is not in verbose format, but there is at least postprocessing step that relies on it,
 				// we need to run the MakeVerboseFormat step first.
+				bool must_join_again = false;
 				if (scenecopy->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
 					
 					bool verbosify = false;
@@ -277,6 +283,10 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
 
 						MakeVerboseFormatProcess proc;
 						proc.Execute(scenecopy.get());
+
+						if(!(exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
+							must_join_again = true;
+						}
 					}
 				}
 
@@ -321,6 +331,11 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
 					privOut->mPPStepsApplied |= pp;
 				}
 
+				if(must_join_again) {
+					JoinVerticesProcess proc;
+					proc.Execute(scenecopy.get());
+				}
+
 				exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get());
 			}
 			catch (DeadlyExportError& err) {

code/STLExporter.cpp

@@ -63,12 +63,25 @@ void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
 
 	outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
 }
+void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene)
+{
+	// invoke the exporter 
+	STLExporter exporter(pFile, pScene, true);
+
+	// we're still here - export successfully completed. Write the file.
+	boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+	if(outfile == NULL) {
+		throw DeadlyExportError("could not open output .stl file: " + std::string(pFile));
+	}
+
+	outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
+}
 
 } // end of namespace Assimp
 
 
 // ------------------------------------------------------------------------------------------------
-STLExporter :: STLExporter(const char* _filename, const aiScene* pScene)
+STLExporter :: STLExporter(const char* _filename, const aiScene* pScene, bool binary)
 : filename(_filename)
 , pScene(pScene)
 , endl("\n") 
@@ -76,14 +89,31 @@ STLExporter :: STLExporter(const char* _filename, const aiScene* pScene)
 	// make sure that all formatting happens using the standard, C locale and not the user's current locale
 	const std::locale& l = std::locale("C");
 	mOutput.imbue(l);
-
-	const std::string& name = "AssimpScene";
+	if (binary) {
+		char buf[80] = {0} ;
+		buf[0] = 'A'; buf[1] = 's'; buf[2] = 's'; buf[3] = 'i'; buf[4] = 'm'; buf[5] = 'p';
+		buf[6] = 'S'; buf[7] = 'c'; buf[8] = 'e'; buf[9] = 'n'; buf[10] = 'e';
+		mOutput.write(buf, 80);
+		unsigned int meshnum = 0;
+		for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+			for (unsigned int j = 0; j < pScene->mMeshes[i]->mNumFaces; ++j) {
+				meshnum++;
+			}
+		}
+		AI_SWAP4(meshnum);
+		mOutput.write((char *)&meshnum, 4);
+		for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+			WriteMeshBinary(pScene->mMeshes[i]);
+		}
+	} else {
+		const std::string& name = "AssimpScene";
 	
-	mOutput << "solid " << name << endl;
-	for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-		WriteMesh(pScene->mMeshes[i]);
+		mOutput << "solid " << name << endl;
+		for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+			WriteMesh(pScene->mMeshes[i]);
+		}
+		mOutput << "endsolid " << name << endl;
 	}
-	mOutput << "endsolid " << name << endl;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -113,4 +143,31 @@ void STLExporter :: WriteMesh(const aiMesh* m)
 	}
 }
 
+void STLExporter :: WriteMeshBinary(const aiMesh* m)
+{
+	for (unsigned int i = 0; i < m->mNumFaces; ++i) {
+		const aiFace& f = m->mFaces[i];
+		// we need per-face normals. We specified aiProcess_GenNormals as pre-requisite for this exporter,
+		// but nonetheless we have to expect per-vertex normals.
+		aiVector3D nor;
+		if (m->mNormals) {
+			for(unsigned int a = 0; a < f.mNumIndices; ++a) {
+				nor += m->mNormals[f.mIndices[a]];
+			}
+			nor.Normalize();
+		}
+		float nx = nor.x, ny = nor.y, nz = nor.z;
+		AI_SWAP4(nx); AI_SWAP4(ny); AI_SWAP4(nz);
+		mOutput.write((char *)&nx, 4); mOutput.write((char *)&ny, 4); mOutput.write((char *)&nz, 4);
+		for(unsigned int a = 0; a < f.mNumIndices; ++a) {
+			const aiVector3D& v  = m->mVertices[f.mIndices[a]];
+			float vx = v.x, vy = v.y, vz = v.z;
+			AI_SWAP4(vx); AI_SWAP4(vy); AI_SWAP4(vz);
+			mOutput.write((char *)&vx, 4); mOutput.write((char *)&vy, 4); mOutput.write((char *)&vz, 4);
+		}
+		char dummy[2] = {0};
+		mOutput.write(dummy, 2);
+	}
+}
+
 #endif

code/STLExporter.h

@@ -59,7 +59,7 @@ class STLExporter
 {
 public:
 	/// Constructor for a specific scene to export
-	STLExporter(const char* filename, const aiScene* pScene);
+	STLExporter(const char* filename, const aiScene* pScene, bool binary = false);
 
 public:
 
@@ -69,6 +69,7 @@ public:
 private:
 
 	void WriteMesh(const aiMesh* m);
+	void WriteMeshBinary(const aiMesh* m);
 
 private: