contrib/brushexport/export.cpp

   1 #include "export.h"
   2 #include "globaldefs.h"
   3 #include "debugging/debugging.h"
   4 #include "ibrush.h"
   5 #include "iscenegraph.h"
   6 #include "iselection.h"
   7 #include "stream/stringstream.h"
   8 #include "stream/textfilestream.h"
   9
  10 #include <map>
  11
  12 // this is very evil, but right now there is no better way
  13 #include "../../radiant/brush.h"
  14
  15 // for limNames
  16 const int MAX_MATERIAL_NAME = 20;
  17
  18 /*
  19     Abstract baseclass for modelexporters
  20     the class collects all the data which then gets
  21     exported through the WriteToFile method.
  22  */
  23 class ExportData
  24 {
  25 public:
  26 ExportData( const std::set<std::string>& ignorelist, collapsemode mode, bool limNames, bool objs );
  27 virtual ~ExportData( void );
  28
  29 virtual void BeginBrush( Brush& b );
  30 virtual void AddBrushFace( Face& f );
  31 virtual void EndBrush( void );
  32
  33 virtual bool WriteToFile( const std::string& path, collapsemode mode ) const = 0;
  34
  35 protected:
  36
  37 // a group of faces
  38 class group
  39 {
  40 public:
  41 std::string name;
  42 std::list<const Face*> faces;
  43 };
  44
  45 std::list<group> groups;
  46
  47 private:
  48
  49 // "textures/common/caulk" -> "caulk"
  50 void GetShaderNameFromShaderPath( const char* path, std::string& name );
  51
  52 group* current;
  53 collapsemode mode;
  54 const std::set<std::string>& ignorelist;
  55 };
  56
  57 ExportData::ExportData( const std::set<std::string>& _ignorelist, collapsemode _mode, bool _limNames, bool _objs )
  58         :   mode( _mode ),
  59         ignorelist( _ignorelist ){
  60         current = 0;
  61
  62         // in this mode, we need just one group
  63         if ( mode == COLLAPSE_ALL ) {
  64                 groups.push_back( group() );
  65                 current = &groups.back();
  66                 current->name = "all";
  67         }
  68 }
  69
  70 ExportData::~ExportData( void ){
  71
  72 }
  73
  74 void ExportData::BeginBrush( Brush& b ){
  75         // create a new group for each brush
  76         if ( mode == COLLAPSE_NONE ) {
  77                 groups.push_back( group() );
  78                 current = &groups.back();
  79
  80                 StringOutputStream str( 256 );
  81                 str << "Brush" << (const unsigned int)groups.size();
  82                 current->name = str.c_str();
  83         }
  84 }
  85
  86 void ExportData::EndBrush( void ){
  87         // all faces of this brush were on the ignorelist, discard the emptygroup
  88         if ( mode == COLLAPSE_NONE ) {
  89                 ASSERT_NOTNULL( current );
  90                 if ( current->faces.empty() ) {
  91                         groups.pop_back();
  92                         current = 0;
  93                 }
  94         }
  95 }
  96
  97 void ExportData::AddBrushFace( Face& f ){
  98         std::string shadername;
  99         GetShaderNameFromShaderPath( f.GetShader(), shadername );
 100
 101         // ignore faces from ignore list
 102         if ( ignorelist.find( shadername ) != ignorelist.end() ) {
 103                 return;
 104         }
 105
 106         if ( mode == COLLAPSE_BY_MATERIAL ) {
 107                 // find a group for this material
 108                 current = 0;
 109                 const std::list<group>::iterator end( groups.end() );
 110                 for ( std::list<group>::iterator it( groups.begin() ); it != end; ++it )
 111                 {
 112                         if ( it->name == shadername ) {
 113                                 current = &( *it );
 114                         }
 115                 }
 116
 117                 // no group found, create one
 118                 if ( !current ) {
 119                         groups.push_back( group() );
 120                         current = &groups.back();
 121                         current->name = shadername;
 122                 }
 123         }
 124
 125         ASSERT_NOTNULL( current );
 126
 127         // add face to current group
 128         current->faces.push_back( &f );
 129
 130 #if GDEF_DEBUG
 131         globalOutputStream() << "Added Face to group " << current->name.c_str() << "\n";
 132 #endif
 133 }
 134
 135 void ExportData::GetShaderNameFromShaderPath( const char* path, std::string& name ){
 136         std::string tmp( path );
 137
 138         size_t last_slash = tmp.find_last_of( "/" );
 139
 140         if ( last_slash != std::string::npos && last_slash == ( tmp.length() - 1 ) ) {
 141                 name = path;
 142         }
 143         else{
 144                 name = tmp.substr( last_slash + 1, tmp.length() - last_slash );
 145         }
 146
 147 #if GDEF_DEBUG
 148         globalOutputStream() << "Last: " << (const unsigned int) last_slash << " " << "length: " << (const unsigned int)tmp.length() << "Name: " << name.c_str() << "\n";
 149 #endif
 150 }
 151
 152 /*
 153     Exporter writing facedata as wavefront object
 154  */
 155 class ExportDataAsWavefront : public ExportData
 156 {
 157 private:
 158 bool expmat;
 159 bool limNames;
 160 bool objs;
 161
 162 public:
 163 ExportDataAsWavefront( const std::set<std::string>& _ignorelist, collapsemode _mode, bool _expmat, bool _limNames, bool _objs )
 164         : ExportData( _ignorelist, _mode, _limNames, _objs ){
 165         expmat = _expmat;
 166         limNames = _limNames;
 167         objs = _objs;
 168 }
 169
 170 bool WriteToFile( const std::string& path, collapsemode mode ) const;
 171 };
 172
 173 bool ExportDataAsWavefront::WriteToFile( const std::string& path, collapsemode mode ) const {
 174         std::string objFile = path;
 175
 176         if ( path.compare( path.length() - 4, 4, ".obj" ) != 0 ) {
 177                 objFile += ".obj";
 178         }
 179
 180         std::string mtlFile = objFile.substr( 0, objFile.length() - 4 ) + ".mtl";
 181
 182         std::set<std::string> materials;
 183
 184         TextFileOutputStream out( objFile.c_str() );
 185
 186         if ( out.failed() ) {
 187                 globalErrorStream() << "Unable to open file\n";
 188                 return false;
 189         }
 190
 191         out << "# Wavefront Objectfile exported with radiants brushexport plugin 3.0 by Thomas 'namespace' Nitschke, spam@codecreator.net\n\n";
 192
 193         if ( expmat ) {
 194                 size_t last = mtlFile.find_last_of( "//" );
 195                 std::string mtllib = mtlFile.substr( last + 1, mtlFile.size() - last ).c_str();
 196                 out << "mtllib " << mtllib.c_str() << "\n";
 197         }
 198
 199         unsigned int vertex_count = 0;
 200
 201         const std::list<ExportData::group>::const_iterator gend( groups.end() );
 202         for ( std::list<ExportData::group>::const_iterator git( groups.begin() ); git != gend; ++git )
 203         {
 204                 typedef std::multimap<std::string, std::string> bm;
 205                 bm brushMaterials;
 206                 typedef std::pair<std::string, std::string> String_Pair;
 207
 208                 const std::list<const Face*>::const_iterator end( git->faces.end() );
 209
 210                 // submesh starts here
 211                 if ( objs ) {
 212                         out << "\no ";
 213                 }
 214                 else {
 215                         out << "\ng ";
 216                 }
 217                 out << git->name.c_str() << "\n";
 218
 219                 // material
 220                 if ( expmat && mode == COLLAPSE_ALL ) {
 221                         out << "usemtl material" << "\n\n";
 222                         materials.insert( "material" );
 223                 }
 224
 225                 for ( std::list<const Face*>::const_iterator it( git->faces.begin() ); it != end; ++it )
 226                 {
 227                         const Winding& w( ( *it )->getWinding() );
 228
 229                         // vertices
 230                         for ( size_t i = 0; i < w.numpoints; ++i )
 231                                 out << "v " << FloatFormat( w[i].vertex.x(), 1, 6 ) << " " << FloatFormat( w[i].vertex.z(), 1, 6 ) << " " << FloatFormat( w[i].vertex.y(), 1, 6 ) << "\n";
 232                 }
 233                 out << "\n";
 234
 235                 for ( std::list<const Face*>::const_iterator it( git->faces.begin() ); it != end; ++it )
 236                 {
 237                         const Winding& w( ( *it )->getWinding() );
 238
 239                         // texcoords
 240                         for ( size_t i = 0; i < w.numpoints; ++i )
 241                                 out << "vt " << FloatFormat( w[i].texcoord.x(), 1, 6 ) << " " << FloatFormat( w[i].texcoord.y(), 1, 6 ) << "\n";
 242                 }
 243
 244                 for ( std::list<const Face*>::const_iterator it( git->faces.begin() ); it != end; ++it )
 245                 {
 246                         const Winding& w( ( *it )->getWinding() );
 247
 248                         // faces
 249                         StringOutputStream faceLine( 256 );
 250                         faceLine << "\nf";
 251                         for ( size_t i = 0; i < w.numpoints; ++i, ++vertex_count )
 252                         {
 253                                 faceLine << " " << vertex_count + 1 << "/" << vertex_count + 1;
 254                         }
 255
 256                         if ( mode != COLLAPSE_ALL ) {
 257                                 materials.insert( ( *it )->getShader().getShader() );
 258                                 brushMaterials.insert( String_Pair( ( *it )->getShader().getShader(), faceLine.c_str() ) );
 259                         }
 260                         else {
 261                                 out << faceLine.c_str();
 262                         }
 263                 }
 264
 265                 if ( mode != COLLAPSE_ALL ) {
 266                         std::string lastMat;
 267                         std::string mat;
 268                         std::string faces;
 269
 270                         for ( bm::iterator iter = brushMaterials.begin(); iter != brushMaterials.end(); iter++ )
 271                         {
 272                                 mat = ( *iter ).first.c_str();
 273                                 faces = ( *iter ).second.c_str();
 274
 275                                 if ( mat != lastMat ) {
 276                                         if ( limNames && mat.size() > MAX_MATERIAL_NAME ) {
 277                                                 out << "\nusemtl " << mat.substr( mat.size() - MAX_MATERIAL_NAME, mat.size() ).c_str();
 278                                         }
 279                                         else {
 280                                                 out << "\nusemtl " << mat.c_str();
 281                                         }
 282                                 }
 283
 284                                 out << faces.c_str();
 285                                 lastMat = mat;
 286                         }
 287                 }
 288
 289                 out << "\n";
 290         }
 291
 292         if ( expmat ) {
 293                 TextFileOutputStream outMtl( mtlFile.c_str() );
 294                 if ( outMtl.failed() ) {
 295                         globalErrorStream() << "Unable to open material file\n";
 296                         return false;
 297                 }
 298
 299                 outMtl << "# Wavefront material file exported with " RADIANT_NAME " brushexport plugin.\n";
 300                 outMtl << "# Material Count: " << (const Unsigned)materials.size() << "\n\n";
 301                 for ( std::set<std::string>::const_iterator it( materials.begin() ); it != materials.end(); ++it )
 302                 {
 303                         if ( limNames && it->size() > MAX_MATERIAL_NAME ) {
 304                                 outMtl << "newmtl " << it->substr( it->size() - MAX_MATERIAL_NAME, it->size() ).c_str() << "\n";
 305                         }
 306                         else {
 307                                 outMtl << "newmtl " << it->c_str() << "\n";
 308                         }
 309                 }
 310         }
 311
 312         return true;
 313 }
 314
 315
 316 class ForEachFace : public BrushVisitor
 317 {
 318 public:
 319 ForEachFace( ExportData& _exporter )
 320         : exporter( _exporter )
 321 {}
 322
 323 void visit( Face& face ) const {
 324         exporter.AddBrushFace( face );
 325 }
 326
 327 private:
 328 ExportData& exporter;
 329 };
 330
 331 class ForEachSelected : public SelectionSystem::Visitor
 332 {
 333 public:
 334 ForEachSelected( ExportData& _exporter )
 335         : exporter( _exporter )
 336 {}
 337
 338 void visit( scene::Instance& instance ) const {
 339         BrushInstance* bptr = InstanceTypeCast<BrushInstance>::cast( instance );
 340         if ( bptr ) {
 341                 Brush& brush( bptr->getBrush() );
 342
 343                 exporter.BeginBrush( brush );
 344                 ForEachFace face_vis( exporter );
 345                 brush.forEachFace( face_vis );
 346                 exporter.EndBrush();
 347         }
 348 }
 349
 350 private:
 351 ExportData& exporter;
 352 };
 353
 354 bool ExportSelection( const std::set<std::string>& ignorelist, collapsemode m, bool exmat, const std::string& path, bool limNames, bool objs ){
 355         ExportDataAsWavefront exporter( ignorelist, m, exmat, limNames, objs );
 356
 357         ForEachSelected vis( exporter );
 358         GlobalSelectionSystem().foreachSelected( vis );
 359
 360         return exporter.WriteToFile( path, m );
 361 }