301 lines
8.9 KiB
C++
301 lines
8.9 KiB
C++
|
|
/** @file LDrawImporter.cpp
|
|
* @brief Implementation of the LDraw importer.
|
|
*/
|
|
#ifndef ASSIMP_BUILD_NO_LDR_IMPORTER
|
|
#include "LDrawImporter.h"
|
|
|
|
using namespace Assimp;
|
|
|
|
static const aiImporterDesc desc = {
|
|
"LDraw Importer",
|
|
"Tobias 'diiigle' Rittig",
|
|
"",
|
|
"ignoring Linetype 5 'optional lines'",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"ldr dat mpd"
|
|
};
|
|
|
|
LDrawImporter::LDrawImporter()
|
|
{
|
|
}
|
|
|
|
LDrawImporter::~LDrawImporter()
|
|
{
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------
|
|
// Returns whether the class can handle the format of the given file.
|
|
bool LDrawImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler,
|
|
bool checkSig) const
|
|
{
|
|
const std::string extension = GetExtension(pFile);
|
|
if (extension == "ldr" || extension == "dat" || extension == "mpd") {
|
|
return true;
|
|
}
|
|
if (!extension.length() || checkSig) {
|
|
const char* tokens[] = { "0 !LDRAW_ORG", "0 !LICENSE" };
|
|
return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 2);
|
|
}
|
|
return false;
|
|
}
|
|
// -------------------------------------------------------------------------------
|
|
const aiImporterDesc* LDrawImporter::GetInfo() const
|
|
{
|
|
return &desc;
|
|
}
|
|
// -------------------------------------------------------------------------------
|
|
void LDrawImporter::SetupProperties(const Importer* pImp)
|
|
{
|
|
_libPath = pImp->GetPropertyString(AI_CONFIG_IMPORT_LDRAW_LIB_PATH, "");
|
|
}
|
|
// -------------------------------------------------------------------------------
|
|
void LDrawImporter::InternReadFile(const std::string& pFile,
|
|
aiScene* pScene, IOSystem* pIOHandler)
|
|
{
|
|
boost::scoped_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
|
|
// Check whether we can read from the file
|
|
if (file.get() == NULL) {
|
|
ThrowException("Failed to open LDraw file " + pFile + ".");
|
|
}
|
|
|
|
// Your task: fill pScene
|
|
// Throw a ImportErrorException with a meaningful (!) error message if
|
|
// something goes wrong.
|
|
std::vector<char> vecBuffer;
|
|
TextFileToBuffer(file.get(), vecBuffer);
|
|
|
|
const char * buffer = &vecBuffer[0];
|
|
|
|
char DS = pIOHandler->getOsSeparator();
|
|
//ensure _libPath points to a valid path
|
|
if (_libPath == ""){
|
|
//use the models folder as root
|
|
_libPath = GetFolderPath(pFile, DS);
|
|
}
|
|
else if (_libPath.find_last_of(DS) != (_libPath.size() - 1))
|
|
{
|
|
_libPath += DS;
|
|
}
|
|
|
|
//setup a batch loader, it's quite probable we will need it
|
|
BatchLoader loader(pIOHandler);
|
|
BatchLoader::PropertyMap loaderParams = BatchLoader::PropertyMap();
|
|
SetGenericProperty(loaderParams.strings, AI_CONFIG_IMPORT_LDRAW_LIB_PATH, _libPath);
|
|
|
|
//TODO estimate sizes
|
|
std::vector<aiVector3D> vertices = std::vector<aiVector3D>();
|
|
std::vector<aiFace> faces = std::vector<aiFace>();
|
|
std::vector<std::pair<unsigned int, aiMatrix4x4*>> fileIds = std::vector<std::pair<unsigned int, aiMatrix4x4*>>();
|
|
|
|
unsigned int primitivesType = 0;
|
|
|
|
//iterate line by line
|
|
char line[4096];
|
|
while (GetNextLine(buffer, line))
|
|
{
|
|
//line pointer, used as iterator through the line
|
|
const char* lp = line;
|
|
|
|
std::string wholeline = std::string(line);
|
|
|
|
SkipSpaces(&lp);
|
|
if (IsLineEnd(*lp))continue;
|
|
if (IsNumeric(*lp)){
|
|
int command = ::atoi(lp);
|
|
++lp;
|
|
if (command == 0){
|
|
//it's a comment
|
|
continue;
|
|
}
|
|
else if (command == 1){
|
|
//it's a sub file reference, load it
|
|
float * params = NULL;
|
|
//read a colour constant and 12 floats of a 4x4 matrix
|
|
if (!ReadNumFloats(lp, params, 13)){
|
|
ThrowException(Formatter::format("could not read ") << 13 << " command parameter floats from the line '" << line << "'");
|
|
}
|
|
aiMatrix4x4 *mat = new aiMatrix4x4(
|
|
params[4], params[5], params[6], params[1],
|
|
params[7], params[8], params[9], params[2],
|
|
params[10], params[11], params[12], params[3],
|
|
0.0f, 0.0f, 0.0f, 1.0f
|
|
);
|
|
//we read 13 tokens from lp, so we can safely skip them
|
|
for (unsigned int i = 0; i < 13; ++i){
|
|
SkipToken(lp);
|
|
}
|
|
std::string subpath = GetNextToken(lp);
|
|
if (subpath == ""){
|
|
ThrowException("sub-file reference with empty path/filename");
|
|
}
|
|
|
|
//find the full path of the part
|
|
std::string fullpath;
|
|
if (pIOHandler->Exists(subpath)){
|
|
//we are lucky, file is full path referenced
|
|
fullpath = subpath;
|
|
}
|
|
else
|
|
{
|
|
//test the specified directories of the LDraw Library
|
|
static std::vector<std::string> paths{ "parts", "p", "models" };
|
|
for (unsigned int i = 0; i < paths.size(); ++i){
|
|
if (pIOHandler->Exists(_libPath + paths[i] + DS + subpath)){
|
|
fullpath = _libPath + paths[i] + DS + subpath;
|
|
break;
|
|
}
|
|
else if (pIOHandler->Exists(_libPath + ".." + DS+ paths[i] + DS + subpath))
|
|
{
|
|
fullpath = _libPath + ".." + DS + paths[i] + DS + subpath;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (fullpath == ""){
|
|
//we can't find it
|
|
ThrowException("Unable to find file '" + subpath + "'");
|
|
}
|
|
unsigned int id = loader.AddLoadRequest(fullpath, 0, &loaderParams);
|
|
fileIds.push_back(std::pair<unsigned int, aiMatrix4x4*>(id, mat));
|
|
continue;
|
|
}
|
|
else if (command == 2 || command == 3 || command == 4){
|
|
//it's a line or a triangle or a quad
|
|
float * params = NULL;
|
|
//read a colour constant and 2 (line) or 3 (triangle) or 4 (quad) vertices
|
|
if (!ReadNumFloats(lp, params, 1 + (command * 3))){
|
|
ThrowException(Formatter::format("could not read ") << (1 + (command * 3)) <<" command parameter floats from the line '" << line<<"'");
|
|
}
|
|
unsigned int index = vertices.size();
|
|
|
|
//TODO colour @params[0]
|
|
|
|
vertices.push_back(aiVector3D(params[1], params[2], params[3]));
|
|
vertices.push_back(aiVector3D(params[4], params[5], params[6]));
|
|
|
|
aiFace f = aiFace();
|
|
f.mNumIndices = command;
|
|
f.mIndices = new unsigned int[command];
|
|
f.mIndices[0] = index;
|
|
f.mIndices[1] = index + 1;
|
|
if (command == 3 || command == 4){
|
|
|
|
vertices.push_back(aiVector3D(params[7], params[8], params[9]));
|
|
f.mIndices[2] = index + 2;
|
|
|
|
if (command == 3){
|
|
//it's a triangle
|
|
primitivesType = primitivesType | aiPrimitiveType_TRIANGLE;
|
|
}
|
|
else if (command == 4){
|
|
//it's a quad
|
|
vertices.push_back(aiVector3D(params[10], params[11], params[12]));
|
|
f.mIndices[3] = index + 3;
|
|
primitivesType = primitivesType | aiPrimitiveType_POLYGON;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//it's a line
|
|
primitivesType = primitivesType | aiPrimitiveType_LINE;
|
|
}
|
|
faces.push_back(f);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
//it's an optional 'line' or an unknown command, ignore them
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Line starts not with an identifier
|
|
ThrowException("Line not starting with an Command Identifier");
|
|
}
|
|
}
|
|
aiScene * master = new aiScene();
|
|
|
|
//we did read the whole file, now build the scenegraph
|
|
master->mRootNode = new aiNode(pFile);
|
|
master->mRootNode->mTransformation = aiMatrix4x4();
|
|
|
|
if (vertices.size() && faces.size())
|
|
{
|
|
master->mNumMeshes = 1;
|
|
master->mMeshes = new aiMesh*[master->mNumMeshes];
|
|
//master->mFlags = AI_SCENE_FLAGS_INCOMPLETE;
|
|
|
|
aiMesh* mesh = new aiMesh();
|
|
mesh->mNumFaces = faces.size();
|
|
mesh->mFaces = new aiFace[mesh->mNumFaces];
|
|
std::copy(faces.begin(), faces.end(), mesh->mFaces);
|
|
mesh->mNumVertices = vertices.size();
|
|
mesh->mVertices = new aiVector3D[mesh->mNumVertices];
|
|
std::copy(vertices.begin(), vertices.end(), mesh->mVertices);
|
|
mesh->mPrimitiveTypes = primitivesType;
|
|
master->mMeshes[0] = mesh;
|
|
|
|
master->mRootNode->mNumMeshes = 1;
|
|
master->mRootNode->mMeshes = new unsigned int[master->mRootNode->mNumMeshes];
|
|
master->mRootNode->mMeshes[0] = 0;
|
|
}
|
|
|
|
if (fileIds.size() != 0){
|
|
//we did queue some sub files, get them
|
|
loader.LoadAll();
|
|
std::vector<AttachmentInfo> attatched(fileIds.size());
|
|
for (unsigned int i = 0; i < fileIds.size(); ++i)
|
|
{
|
|
aiScene* sc = loader.GetImport(fileIds[i].first);
|
|
//check for duplicates with diffrent transformation matrix
|
|
int duplID = -1;
|
|
for (unsigned int j = 0; j < fileIds.size(); j++){
|
|
if (j == i) continue; //don't check ourself for duplicates
|
|
if (fileIds[j].first == fileIds[i].first && *fileIds[j].second != *fileIds[i].second){
|
|
//we found a scene with same id but diffrent transformation => true duplicate
|
|
duplID = j;
|
|
break;
|
|
}
|
|
}
|
|
aiScene * scene;
|
|
if (duplID != -1 && duplID < i){
|
|
//duplicate was found and loaded scene was already used
|
|
SceneCombiner::CopyScene(&scene, sc);
|
|
}
|
|
else
|
|
{
|
|
scene = sc;
|
|
}
|
|
|
|
scene->mRootNode->mTransformation = *fileIds[i].second;
|
|
attatched[i] = AttachmentInfo(scene, master->mRootNode);
|
|
}
|
|
SceneCombiner::MergeScenes(&pScene, master, attatched, AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY);
|
|
}
|
|
else
|
|
{
|
|
SceneCombiner::CopySceneFlat(&pScene, master);
|
|
}
|
|
}
|
|
|
|
bool LDrawImporter::ReadNumFloats(const char* line, float* & out, unsigned int num)
|
|
{
|
|
out = new float[num];
|
|
for (unsigned int i = 0; i < num; ++i){
|
|
std::string token = GetNextToken(line);
|
|
if (token == ""){
|
|
//unexpected end of line
|
|
return false;
|
|
}
|
|
out[i] = fast_atof(token.c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif // !ASSIMP_BUILD_NO_LDR_IMPORTER
|