mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-13 19:53:48 +00:00
WIP of assimp integration.
This commit is contained in:
Areloch
parent
32c7f2c7a7
commit
bf170ffbca
2135 changed files with 1260856 additions and 7 deletions
902
Engine/lib/assimp/code/DXFLoader.cpp
Normal file
902
Engine/lib/assimp/code/DXFLoader.cpp
Normal file
|
|
@ -0,0 +1,902 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2018, 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 DXFLoader.cpp
|
||||
* @brief Implementation of the DXF importer class
|
||||
*/
|
||||
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
|
||||
|
||||
#include "DXFLoader.h"
|
||||
#include <assimp/ParsingUtils.h>
|
||||
#include "ConvertToLHProcess.h"
|
||||
#include <assimp/fast_atof.h>
|
||||
|
||||
#include "DXFHelper.h"
|
||||
#include <assimp/IOSystem.hpp>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/importerdesc.h>
|
||||
|
||||
#include <numeric>
|
||||
|
||||
using namespace Assimp;
|
||||
|
||||
// AutoCAD Binary DXF<CR><LF><SUB><NULL>
|
||||
#define AI_DXF_BINARY_IDENT ("AutoCAD Binary DXF\r\n\x1a\0")
|
||||
#define AI_DXF_BINARY_IDENT_LEN (24)
|
||||
|
||||
// default vertex color that all uncolored vertices will receive
|
||||
#define AI_DXF_DEFAULT_COLOR aiColor4D(0.6f,0.6f,0.6f,0.6f)
|
||||
|
||||
// color indices for DXF - 16 are supported, the table is
|
||||
// taken directly from the DXF spec.
|
||||
static aiColor4D g_aclrDxfIndexColors[] =
|
||||
{
|
||||
aiColor4D (0.6f, 0.6f, 0.6f, 1.0f),
|
||||
aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red
|
||||
aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green
|
||||
aiColor4D (0.0f, 0.0f, 1.0f, 1.0f), // blue
|
||||
aiColor4D (0.3f, 1.0f, 0.3f, 1.0f), // light green
|
||||
aiColor4D (0.3f, 0.3f, 1.0f, 1.0f), // light blue
|
||||
aiColor4D (1.0f, 0.3f, 0.3f, 1.0f), // light red
|
||||
aiColor4D (1.0f, 0.0f, 1.0f, 1.0f), // pink
|
||||
aiColor4D (1.0f, 0.6f, 0.0f, 1.0f), // orange
|
||||
aiColor4D (0.6f, 0.3f, 0.0f, 1.0f), // dark orange
|
||||
aiColor4D (1.0f, 1.0f, 0.0f, 1.0f), // yellow
|
||||
aiColor4D (0.3f, 0.3f, 0.3f, 1.0f), // dark gray
|
||||
aiColor4D (0.8f, 0.8f, 0.8f, 1.0f), // light gray
|
||||
aiColor4D (0.0f, 00.f, 0.0f, 1.0f), // black
|
||||
aiColor4D (1.0f, 1.0f, 1.0f, 1.0f), // white
|
||||
aiColor4D (0.6f, 0.0f, 1.0f, 1.0f) // violet
|
||||
};
|
||||
#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0]))
|
||||
#define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC"
|
||||
|
||||
|
||||
static const aiImporterDesc desc = {
|
||||
"Drawing Interchange Format (DXF) Importer",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
"dxf"
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Constructor to be privately used by Importer
|
||||
DXFImporter::DXFImporter()
|
||||
{}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Destructor, private as well
|
||||
DXFImporter::~DXFImporter()
|
||||
{}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Returns whether the class can handle the format of the given file.
|
||||
bool DXFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const {
|
||||
const std::string& extension = GetExtension( pFile );
|
||||
if ( extension == "dxf" ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if ( extension.empty() || checkSig ) {
|
||||
static const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
|
||||
return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 4, 32 );
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Get a list of all supported file extensions
|
||||
const aiImporterDesc* DXFImporter::GetInfo () const
|
||||
{
|
||||
return &desc;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Imports the given file into the given scene structure.
|
||||
void DXFImporter::InternReadFile( const std::string& pFile,
|
||||
aiScene* pScene,
|
||||
IOSystem* pIOHandler)
|
||||
{
|
||||
std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
|
||||
|
||||
// Check whether we can read the file
|
||||
if( file.get() == NULL) {
|
||||
throw DeadlyImportError( "Failed to open DXF file " + pFile + "");
|
||||
}
|
||||
|
||||
// check whether this is a binaray DXF file - we can't read binary DXF files :-(
|
||||
char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
|
||||
file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
|
||||
|
||||
if (!strncmp(AI_DXF_BINARY_IDENT,buff,AI_DXF_BINARY_IDENT_LEN)) {
|
||||
throw DeadlyImportError("DXF: Binary files are not supported at the moment");
|
||||
}
|
||||
|
||||
// DXF files can grow very large, so read them via the StreamReader,
|
||||
// which will choose a suitable strategy.
|
||||
file->Seek(0,aiOrigin_SET);
|
||||
StreamReaderLE stream( file );
|
||||
|
||||
DXF::LineReader reader (stream);
|
||||
DXF::FileData output;
|
||||
|
||||
// now get all lines of the file and process top-level sections
|
||||
bool eof = false;
|
||||
while(!reader.End()) {
|
||||
|
||||
// blocks table - these 'build blocks' are later (in ENTITIES)
|
||||
// referenced an included via INSERT statements.
|
||||
if (reader.Is(2,"BLOCKS")) {
|
||||
ParseBlocks(reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
// primary entity table
|
||||
if (reader.Is(2,"ENTITIES")) {
|
||||
ParseEntities(reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
// skip unneeded sections entirely to avoid any problems with them
|
||||
// altogether.
|
||||
else if (reader.Is(2,"CLASSES") || reader.Is(2,"TABLES")) {
|
||||
SkipSection(reader);
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (reader.Is(2,"HEADER")) {
|
||||
ParseHeader(reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
// comments
|
||||
else if (reader.Is(999)) {
|
||||
ASSIMP_LOG_INFO_F("DXF Comment: ", reader.Value());
|
||||
}
|
||||
|
||||
// don't read past the official EOF sign
|
||||
else if (reader.Is(0,"EOF")) {
|
||||
eof = true;
|
||||
break;
|
||||
}
|
||||
|
||||
++reader;
|
||||
}
|
||||
if (!eof) {
|
||||
ASSIMP_LOG_WARN("DXF: EOF reached, but did not encounter DXF EOF marker");
|
||||
}
|
||||
|
||||
ConvertMeshes(pScene,output);
|
||||
|
||||
// Now rotate the whole scene by 90 degrees around the x axis to convert from AutoCAD's to Assimp's coordinate system
|
||||
pScene->mRootNode->mTransformation = aiMatrix4x4(
|
||||
1.f,0.f,0.f,0.f,
|
||||
0.f,0.f,1.f,0.f,
|
||||
0.f,-1.f,0.f,0.f,
|
||||
0.f,0.f,0.f,1.f) * pScene->mRootNode->mTransformation;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
|
||||
{
|
||||
// the process of resolving all the INSERT statements can grow the
|
||||
// poly-count excessively, so log the original number.
|
||||
// XXX Option to import blocks as separate nodes?
|
||||
if (!DefaultLogger::isNullLogger()) {
|
||||
|
||||
unsigned int vcount = 0, icount = 0;
|
||||
for (const DXF::Block& bl : output.blocks) {
|
||||
for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) {
|
||||
vcount += static_cast<unsigned int>(pl->positions.size());
|
||||
icount += static_cast<unsigned int>(pl->counts.size());
|
||||
}
|
||||
}
|
||||
|
||||
ASSIMP_LOG_DEBUG_F("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount);
|
||||
}
|
||||
|
||||
if (! output.blocks.size() ) {
|
||||
throw DeadlyImportError("DXF: no data blocks loaded");
|
||||
}
|
||||
|
||||
DXF::Block* entities( nullptr );
|
||||
|
||||
// index blocks by name
|
||||
DXF::BlockMap blocks_by_name;
|
||||
for (DXF::Block& bl : output.blocks) {
|
||||
blocks_by_name[bl.name] = &bl;
|
||||
if ( !entities && bl.name == AI_DXF_ENTITIES_MAGIC_BLOCK ) {
|
||||
entities = &bl;
|
||||
}
|
||||
}
|
||||
|
||||
if (!entities) {
|
||||
throw DeadlyImportError("DXF: no ENTITIES data block loaded");
|
||||
}
|
||||
|
||||
typedef std::map<std::string, unsigned int> LayerMap;
|
||||
|
||||
LayerMap layers;
|
||||
std::vector< std::vector< const DXF::PolyLine*> > corr;
|
||||
|
||||
// now expand all block references in the primary ENTITIES block
|
||||
// XXX this involves heavy memory copying, consider a faster solution for future versions.
|
||||
ExpandBlockReferences(*entities,blocks_by_name);
|
||||
|
||||
unsigned int cur = 0;
|
||||
for (std::shared_ptr<const DXF::PolyLine> pl : entities->lines) {
|
||||
if (pl->positions.size()) {
|
||||
|
||||
std::map<std::string, unsigned int>::iterator it = layers.find(pl->layer);
|
||||
if (it == layers.end()) {
|
||||
++pScene->mNumMeshes;
|
||||
|
||||
layers[pl->layer] = cur++;
|
||||
|
||||
std::vector< const DXF::PolyLine* > pv;
|
||||
pv.push_back(&*pl);
|
||||
|
||||
corr.push_back(pv);
|
||||
}
|
||||
else {
|
||||
corr[(*it).second].push_back(&*pl);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!pScene->mNumMeshes) {
|
||||
throw DeadlyImportError("DXF: this file contains no 3d data");
|
||||
}
|
||||
|
||||
pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ] ();
|
||||
|
||||
for(const LayerMap::value_type& elem : layers){
|
||||
aiMesh* const mesh = pScene->mMeshes[elem.second] = new aiMesh();
|
||||
mesh->mName.Set(elem.first);
|
||||
|
||||
unsigned int cvert = 0,cface = 0;
|
||||
for(const DXF::PolyLine* pl : corr[elem.second]){
|
||||
// sum over all faces since we need to 'verbosify' them.
|
||||
cvert += std::accumulate(pl->counts.begin(),pl->counts.end(),0);
|
||||
cface += static_cast<unsigned int>(pl->counts.size());
|
||||
}
|
||||
|
||||
aiVector3D* verts = mesh->mVertices = new aiVector3D[cvert];
|
||||
aiColor4D* colors = mesh->mColors[0] = new aiColor4D[cvert];
|
||||
aiFace* faces = mesh->mFaces = new aiFace[cface];
|
||||
|
||||
mesh->mNumVertices = cvert;
|
||||
mesh->mNumFaces = cface;
|
||||
|
||||
unsigned int prims = 0;
|
||||
unsigned int overall_indices = 0;
|
||||
for(const DXF::PolyLine* pl : corr[elem.second]){
|
||||
|
||||
std::vector<unsigned int>::const_iterator it = pl->indices.begin();
|
||||
for(unsigned int facenumv : pl->counts) {
|
||||
aiFace& face = *faces++;
|
||||
face.mIndices = new unsigned int[face.mNumIndices = facenumv];
|
||||
|
||||
for (unsigned int i = 0; i < facenumv; ++i) {
|
||||
face.mIndices[i] = overall_indices++;
|
||||
|
||||
ai_assert(pl->positions.size() == pl->colors.size());
|
||||
if (*it >= pl->positions.size()) {
|
||||
throw DeadlyImportError("DXF: vertex index out of bounds");
|
||||
}
|
||||
|
||||
*verts++ = pl->positions[*it];
|
||||
*colors++ = pl->colors[*it++];
|
||||
}
|
||||
|
||||
// set primitive flags now, this saves the extra pass in ScenePreprocessor.
|
||||
switch(face.mNumIndices) {
|
||||
case 1:
|
||||
prims |= aiPrimitiveType_POINT;
|
||||
break;
|
||||
case 2:
|
||||
prims |= aiPrimitiveType_LINE;
|
||||
break;
|
||||
case 3:
|
||||
prims |= aiPrimitiveType_TRIANGLE;
|
||||
break;
|
||||
default:
|
||||
prims |= aiPrimitiveType_POLYGON;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mesh->mPrimitiveTypes = prims;
|
||||
mesh->mMaterialIndex = 0;
|
||||
}
|
||||
|
||||
GenerateHierarchy(pScene,output);
|
||||
GenerateMaterials(pScene,output);
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name)
|
||||
{
|
||||
for (const DXF::InsertBlock& insert : bl.insertions) {
|
||||
|
||||
// first check if the referenced blocks exists ...
|
||||
const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
|
||||
if (it == blocks_by_name.end()) {
|
||||
ASSIMP_LOG_ERROR_F("DXF: Failed to resolve block reference: ", insert.name,"; skipping" );
|
||||
continue;
|
||||
}
|
||||
|
||||
// XXX this would be the place to implement recursive expansion if needed.
|
||||
const DXF::Block& bl_src = *(*it).second;
|
||||
|
||||
for (std::shared_ptr<const DXF::PolyLine> pl_in : bl_src.lines) {
|
||||
std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
|
||||
|
||||
if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) {
|
||||
// manual coordinate system transformation
|
||||
// XXX order
|
||||
aiMatrix4x4 trafo, tmp;
|
||||
aiMatrix4x4::Translation(-bl_src.base,trafo);
|
||||
trafo *= aiMatrix4x4::Scaling(insert.scale,tmp);
|
||||
trafo *= aiMatrix4x4::Translation(insert.pos,tmp);
|
||||
|
||||
// XXX rotation currently ignored - I didn't find an appropriate sample model.
|
||||
if (insert.angle != 0.f) {
|
||||
ASSIMP_LOG_WARN("DXF: BLOCK rotation not currently implemented");
|
||||
}
|
||||
|
||||
for (aiVector3D& v : pl_out->positions) {
|
||||
v *= trafo;
|
||||
}
|
||||
}
|
||||
|
||||
bl.lines.push_back(pl_out);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
|
||||
{
|
||||
// generate an almost-white default material. Reason:
|
||||
// the default vertex color is GREY, so we are
|
||||
// already at Assimp's usual default color.
|
||||
// generate a default material
|
||||
aiMaterial* pcMat = new aiMaterial();
|
||||
aiString s;
|
||||
s.Set(AI_DEFAULT_MATERIAL_NAME);
|
||||
pcMat->AddProperty(&s, AI_MATKEY_NAME);
|
||||
|
||||
aiColor4D clrDiffuse(0.9f,0.9f,0.9f,1.0f);
|
||||
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);
|
||||
|
||||
clrDiffuse = aiColor4D(1.0f,1.0f,1.0f,1.0f);
|
||||
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);
|
||||
|
||||
clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f);
|
||||
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);
|
||||
|
||||
pScene->mNumMaterials = 1;
|
||||
pScene->mMaterials = new aiMaterial*[1];
|
||||
pScene->mMaterials[0] = pcMat;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
|
||||
{
|
||||
// generate the output scene graph, which is just the root node with a single child for each layer.
|
||||
pScene->mRootNode = new aiNode();
|
||||
pScene->mRootNode->mName.Set("<DXF_ROOT>");
|
||||
|
||||
if (1 == pScene->mNumMeshes) {
|
||||
pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ];
|
||||
pScene->mRootNode->mMeshes[0] = 0;
|
||||
} else {
|
||||
pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ];
|
||||
for (unsigned int m = 0; m < pScene->mRootNode->mNumChildren;++m) {
|
||||
aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode();
|
||||
p->mName = pScene->mMeshes[m]->mName;
|
||||
|
||||
p->mMeshes = new unsigned int[p->mNumMeshes = 1];
|
||||
p->mMeshes[0] = m;
|
||||
p->mParent = pScene->mRootNode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::SkipSection(DXF::LineReader& reader) {
|
||||
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParseHeader(DXF::LineReader& reader, DXF::FileData& ) {
|
||||
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output) {
|
||||
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
||||
if (reader.Is(0,"BLOCK")) {
|
||||
ParseBlock(++reader,output);
|
||||
continue;
|
||||
}
|
||||
++reader;
|
||||
}
|
||||
|
||||
ASSIMP_LOG_DEBUG_F("DXF: got ", output.blocks.size()," entries in BLOCKS" );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
|
||||
// push a new block onto the stack.
|
||||
output.blocks.push_back( DXF::Block() );
|
||||
DXF::Block& block = output.blocks.back();
|
||||
|
||||
while( !reader.End() && !reader.Is(0,"ENDBLK")) {
|
||||
|
||||
switch(reader.GroupCode()) {
|
||||
case 2:
|
||||
block.name = reader.Value();
|
||||
break;
|
||||
|
||||
case 10:
|
||||
block.base.x = reader.ValueAsFloat();
|
||||
break;
|
||||
case 20:
|
||||
block.base.y = reader.ValueAsFloat();
|
||||
break;
|
||||
case 30:
|
||||
block.base.z = reader.ValueAsFloat();
|
||||
break;
|
||||
}
|
||||
|
||||
if (reader.Is(0,"POLYLINE")) {
|
||||
ParsePolyLine(++reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
// XXX is this a valid case?
|
||||
if (reader.Is(0,"INSERT")) {
|
||||
ASSIMP_LOG_WARN("DXF: INSERT within a BLOCK not currently supported; skipping");
|
||||
for( ;!reader.End() && !reader.Is(0,"ENDBLK"); ++reader);
|
||||
break;
|
||||
}
|
||||
|
||||
else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) {
|
||||
//http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632
|
||||
Parse3DFace(++reader, output);
|
||||
continue;
|
||||
}
|
||||
++reader;
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
|
||||
{
|
||||
// push a new block onto the stack.
|
||||
output.blocks.push_back( DXF::Block() );
|
||||
DXF::Block& block = output.blocks.back();
|
||||
|
||||
block.name = AI_DXF_ENTITIES_MAGIC_BLOCK;
|
||||
|
||||
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
||||
if (reader.Is(0,"POLYLINE")) {
|
||||
ParsePolyLine(++reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (reader.Is(0,"INSERT")) {
|
||||
ParseInsertion(++reader,output);
|
||||
continue;
|
||||
}
|
||||
|
||||
else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) {
|
||||
//http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632
|
||||
Parse3DFace(++reader, output);
|
||||
continue;
|
||||
}
|
||||
|
||||
++reader;
|
||||
}
|
||||
|
||||
ASSIMP_LOG_DEBUG_F( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(),
|
||||
" inserted blocks in ENTITIES" );
|
||||
}
|
||||
|
||||
void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
|
||||
{
|
||||
output.blocks.back().insertions.push_back( DXF::InsertBlock() );
|
||||
DXF::InsertBlock& bl = output.blocks.back().insertions.back();
|
||||
|
||||
while( !reader.End() && !reader.Is(0)) {
|
||||
switch(reader.GroupCode())
|
||||
{
|
||||
// name of referenced block
|
||||
case 2:
|
||||
bl.name = reader.Value();
|
||||
break;
|
||||
|
||||
// translation
|
||||
case 10:
|
||||
bl.pos.x = reader.ValueAsFloat();
|
||||
break;
|
||||
case 20:
|
||||
bl.pos.y = reader.ValueAsFloat();
|
||||
break;
|
||||
case 30:
|
||||
bl.pos.z = reader.ValueAsFloat();
|
||||
break;
|
||||
|
||||
// scaling
|
||||
case 41:
|
||||
bl.scale.x = reader.ValueAsFloat();
|
||||
break;
|
||||
case 42:
|
||||
bl.scale.y = reader.ValueAsFloat();
|
||||
break;
|
||||
case 43:
|
||||
bl.scale.z = reader.ValueAsFloat();
|
||||
break;
|
||||
|
||||
// rotation angle
|
||||
case 50:
|
||||
bl.angle = reader.ValueAsFloat();
|
||||
break;
|
||||
}
|
||||
reader++;
|
||||
}
|
||||
}
|
||||
|
||||
#define DXF_POLYLINE_FLAG_CLOSED 0x1
|
||||
#define DXF_POLYLINE_FLAG_3D_POLYLINE 0x8
|
||||
#define DXF_POLYLINE_FLAG_3D_POLYMESH 0x10
|
||||
#define DXF_POLYLINE_FLAG_POLYFACEMESH 0x40
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output) {
|
||||
output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
|
||||
DXF::PolyLine& line = *output.blocks.back().lines.back();
|
||||
|
||||
unsigned int iguess = 0, vguess = 0;
|
||||
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
||||
|
||||
if (reader.Is(0,"VERTEX")) {
|
||||
ParsePolyLineVertex(++reader,line);
|
||||
if (reader.Is(0,"SEQEND")) {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
switch(reader.GroupCode())
|
||||
{
|
||||
// flags --- important that we know whether it is a
|
||||
// polyface mesh or 'just' a line.
|
||||
case 70:
|
||||
if (!line.flags) {
|
||||
line.flags = reader.ValueAsSignedInt();
|
||||
}
|
||||
break;
|
||||
|
||||
// optional number of vertices
|
||||
case 71:
|
||||
vguess = reader.ValueAsSignedInt();
|
||||
line.positions.reserve(vguess);
|
||||
break;
|
||||
|
||||
// optional number of faces
|
||||
case 72:
|
||||
iguess = reader.ValueAsSignedInt();
|
||||
line.indices.reserve(iguess);
|
||||
break;
|
||||
|
||||
// 8 specifies the layer on which this line is placed on
|
||||
case 8:
|
||||
line.layer = reader.Value();
|
||||
break;
|
||||
}
|
||||
|
||||
reader++;
|
||||
}
|
||||
|
||||
//if (!(line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH)) {
|
||||
// DefaultLogger::get()->warn((Formatter::format("DXF: polyline not currently supported: "),line.flags));
|
||||
// output.blocks.back().lines.pop_back();
|
||||
// return;
|
||||
//}
|
||||
|
||||
if (vguess && line.positions.size() != vguess) {
|
||||
ASSIMP_LOG_WARN_F("DXF: unexpected vertex count in polymesh: ",
|
||||
line.positions.size(),", expected ", vguess );
|
||||
}
|
||||
|
||||
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH ) {
|
||||
if (line.positions.size() < 3 || line.indices.size() < 3) {
|
||||
ASSIMP_LOG_WARN("DXF: not enough vertices for polymesh; ignoring");
|
||||
output.blocks.back().lines.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
// if these numbers are wrong, parsing might have gone wild.
|
||||
// however, the docs state that applications are not required
|
||||
// to set the 71 and 72 fields, respectively, to valid values.
|
||||
// So just fire a warning.
|
||||
if (iguess && line.counts.size() != iguess) {
|
||||
ASSIMP_LOG_WARN_F( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess );
|
||||
}
|
||||
}
|
||||
else if (!line.indices.size() && !line.counts.size()) {
|
||||
// a poly-line - so there are no indices yet.
|
||||
size_t guess = line.positions.size() + (line.flags & DXF_POLYLINE_FLAG_CLOSED ? 1 : 0);
|
||||
line.indices.reserve(guess);
|
||||
|
||||
line.counts.reserve(guess/2);
|
||||
for (unsigned int i = 0; i < line.positions.size()/2; ++i) {
|
||||
line.indices.push_back(i*2);
|
||||
line.indices.push_back(i*2+1);
|
||||
line.counts.push_back(2);
|
||||
}
|
||||
|
||||
// closed polyline?
|
||||
if (line.flags & DXF_POLYLINE_FLAG_CLOSED) {
|
||||
line.indices.push_back(static_cast<unsigned int>(line.positions.size()-1));
|
||||
line.indices.push_back(0);
|
||||
line.counts.push_back(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define DXF_VERTEX_FLAG_PART_OF_POLYFACE 0x80
|
||||
#define DXF_VERTEX_FLAG_HAS_POSITIONS 0x40
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line)
|
||||
{
|
||||
unsigned int cnti = 0, flags = 0;
|
||||
unsigned int indices[4];
|
||||
|
||||
aiVector3D out;
|
||||
aiColor4D clr = AI_DXF_DEFAULT_COLOR;
|
||||
|
||||
while( !reader.End() ) {
|
||||
|
||||
if (reader.Is(0)) { // SEQEND or another VERTEX
|
||||
break;
|
||||
}
|
||||
|
||||
switch (reader.GroupCode())
|
||||
{
|
||||
case 8:
|
||||
// layer to which the vertex belongs to - assume that
|
||||
// this is always the layer the top-level poly-line
|
||||
// entity resides on as well.
|
||||
if(reader.Value() != line.layer) {
|
||||
ASSIMP_LOG_WARN("DXF: expected vertex to be part of a poly-face but the 0x128 flag isn't set");
|
||||
}
|
||||
break;
|
||||
|
||||
case 70:
|
||||
flags = reader.ValueAsUnsignedInt();
|
||||
break;
|
||||
|
||||
// VERTEX COORDINATES
|
||||
case 10: out.x = reader.ValueAsFloat();break;
|
||||
case 20: out.y = reader.ValueAsFloat();break;
|
||||
case 30: out.z = reader.ValueAsFloat();break;
|
||||
|
||||
// POLYFACE vertex indices
|
||||
case 71:
|
||||
case 72:
|
||||
case 73:
|
||||
case 74:
|
||||
if (cnti == 4) {
|
||||
ASSIMP_LOG_WARN("DXF: more than 4 indices per face not supported; ignoring");
|
||||
break;
|
||||
}
|
||||
indices[cnti++] = reader.ValueAsUnsignedInt();
|
||||
break;
|
||||
|
||||
// color
|
||||
case 62:
|
||||
clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS];
|
||||
break;
|
||||
};
|
||||
|
||||
reader++;
|
||||
}
|
||||
|
||||
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH && !(flags & DXF_VERTEX_FLAG_PART_OF_POLYFACE)) {
|
||||
ASSIMP_LOG_WARN("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set");
|
||||
}
|
||||
|
||||
if (cnti) {
|
||||
line.counts.push_back(cnti);
|
||||
for (unsigned int i = 0; i < cnti; ++i) {
|
||||
// IMPORTANT NOTE: POLYMESH indices are ONE-BASED
|
||||
if (indices[i] == 0) {
|
||||
ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based.");
|
||||
--line.counts.back();
|
||||
continue;
|
||||
}
|
||||
line.indices.push_back(indices[i]-1);
|
||||
}
|
||||
} else {
|
||||
line.positions.push_back(out);
|
||||
line.colors.push_back(clr);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
|
||||
{
|
||||
// (note) this is also used for for parsing line entities, so we
|
||||
// must handle the vertex_count == 2 case as well.
|
||||
|
||||
output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
|
||||
DXF::PolyLine& line = *output.blocks.back().lines.back();
|
||||
|
||||
aiVector3D vip[4];
|
||||
aiColor4D clr = AI_DXF_DEFAULT_COLOR;
|
||||
|
||||
bool b[4] = {false,false,false,false};
|
||||
while( !reader.End() ) {
|
||||
|
||||
// next entity with a groupcode == 0 is probably already the next vertex or polymesh entity
|
||||
if (reader.GroupCode() == 0) {
|
||||
break;
|
||||
}
|
||||
switch (reader.GroupCode())
|
||||
{
|
||||
|
||||
// 8 specifies the layer
|
||||
case 8:
|
||||
line.layer = reader.Value();
|
||||
break;
|
||||
|
||||
// x position of the first corner
|
||||
case 10: vip[0].x = reader.ValueAsFloat();
|
||||
b[2] = true;
|
||||
break;
|
||||
|
||||
// y position of the first corner
|
||||
case 20: vip[0].y = reader.ValueAsFloat();
|
||||
b[2] = true;
|
||||
break;
|
||||
|
||||
// z position of the first corner
|
||||
case 30: vip[0].z = reader.ValueAsFloat();
|
||||
b[2] = true;
|
||||
break;
|
||||
|
||||
// x position of the second corner
|
||||
case 11: vip[1].x = reader.ValueAsFloat();
|
||||
b[3] = true;
|
||||
break;
|
||||
|
||||
// y position of the second corner
|
||||
case 21: vip[1].y = reader.ValueAsFloat();
|
||||
b[3] = true;
|
||||
break;
|
||||
|
||||
// z position of the second corner
|
||||
case 31: vip[1].z = reader.ValueAsFloat();
|
||||
b[3] = true;
|
||||
break;
|
||||
|
||||
// x position of the third corner
|
||||
case 12: vip[2].x = reader.ValueAsFloat();
|
||||
b[0] = true;
|
||||
break;
|
||||
|
||||
// y position of the third corner
|
||||
case 22: vip[2].y = reader.ValueAsFloat();
|
||||
b[0] = true;
|
||||
break;
|
||||
|
||||
// z position of the third corner
|
||||
case 32: vip[2].z = reader.ValueAsFloat();
|
||||
b[0] = true;
|
||||
break;
|
||||
|
||||
// x position of the fourth corner
|
||||
case 13: vip[3].x = reader.ValueAsFloat();
|
||||
b[1] = true;
|
||||
break;
|
||||
|
||||
// y position of the fourth corner
|
||||
case 23: vip[3].y = reader.ValueAsFloat();
|
||||
b[1] = true;
|
||||
break;
|
||||
|
||||
// z position of the fourth corner
|
||||
case 33: vip[3].z = reader.ValueAsFloat();
|
||||
b[1] = true;
|
||||
break;
|
||||
|
||||
// color
|
||||
case 62:
|
||||
clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS];
|
||||
break;
|
||||
};
|
||||
|
||||
++reader;
|
||||
}
|
||||
|
||||
// the fourth corner may even be identical to the third,
|
||||
// in this case we treat it as if it didn't exist.
|
||||
if (vip[3] == vip[2]) {
|
||||
b[1] = false;
|
||||
}
|
||||
|
||||
// sanity checks to see if we got something meaningful
|
||||
if ((b[1] && !b[0]) || !b[2] || !b[3]) {
|
||||
ASSIMP_LOG_WARN("DXF: unexpected vertex setup in 3DFACE/LINE/FACE entity; ignoring");
|
||||
output.blocks.back().lines.pop_back();
|
||||
return;
|
||||
}
|
||||
|
||||
const unsigned int cnt = (2+(b[0]?1:0)+(b[1]?1:0));
|
||||
line.counts.push_back(cnt);
|
||||
|
||||
for (unsigned int i = 0; i < cnt; ++i) {
|
||||
line.indices.push_back(static_cast<unsigned int>(line.positions.size()));
|
||||
line.positions.push_back(vip[i]);
|
||||
line.colors.push_back(clr);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_DXF_IMPORTER
|
||||
Loading…
Add table
Add a link
Reference in a new issue