Source/System/FileIO/3DS/OSG3DSSceneFileType.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39
  40 #include <string>
  41
  42 #include "OSGConfig.h"
  43 #include "OSGLog.h"
  44 #include "OSGNode.h"
  45 #include "OSGGeometry.h"
  46 #include "OSGTypedGeoVectorProperty.h"
  47 #include "OSGTypedGeoIntegralProperty.h"
  48 #include "OSGGeoProperty.h"
  49 #include "OSGGroup.h"
  50 #include "OSGSimpleGeometry.h"
  51 #include "OSGGeoProperty.h"
  52 #include "OSGNameAttachment.h"
  53 #include "OSGTriangleIterator.h"
  54 #include "OSGGeoFunctions.h"
  55 #include "OSGChunkMaterial.h"
  56 #include "OSGMaterialChunk.h"
  57 #include "OSGBlendChunk.h"
  58 #include "OSGImage.h"
  59 #include "OSGTextureObjChunk.h"
  60 #include "OSGTextureEnvChunk.h"
  61 #include "OSGImageFileHandler.h"
  62
  63 #include "OSG3DSSceneFileType.h"
  64
  65 OSG_USING_NAMESPACE
  66
  67 const Char8 *A3DSSceneFileType::_suffixA[] = {"3ds"};
  68
  69 A3DSSceneFileType  A3DSSceneFileType::_the(_suffixA,
  70                                            sizeof(_suffixA),
  71                                            false,
  72                                            10,
  73                                            SceneFileType::OSG_READ_SUPPORTED);
  74
  75 NodeTransitPtr A3DSSceneFileType::read(      std::istream &is,
  76                                        const Char8        *,
  77                                              Resolver        ) const
  78 {
  79     if(!is)
  80         return NodeTransitPtr(NULL);
  81
  82     _materials.clear();
  83
  84     L3DS scene;
  85
  86     if(!scene.Load(is))
  87     {
  88         SWARNING << "Couldn't read from stream!" << std::endl;
  89
  90         return NodeTransitPtr(NULL);
  91     }
  92
  93     NodeTransitPtr  root = Node::create();
  94
  95     root->setCore(Group::create());
  96
  97     for(uint i=0;i<scene.GetMeshCount();++i)
  98     {
  99         NodeUnrecPtr mesh = createMesh(scene, scene.GetMesh(i));
 100
 101         if(mesh != NULL)
 102             root->addChild(mesh);
 103     }
 104
 105     _materials.clear();
 106
 107     commitChanges();
 108
 109     return root;
 110 }
 111
 112 A3DSSceneFileType::A3DSSceneFileType(const Char8  *suffixArray[],
 113                                          UInt16  suffixByteCount,
 114                                          bool    override,
 115                                          UInt32  overridePriority,
 116                                          UInt32  flags) :
 117     SceneFileType(suffixArray,
 118                   suffixByteCount,
 119                   override,
 120                   overridePriority,
 121                   flags),
 122     _materials()
 123 {
 124 }
 125
 126
 127 A3DSSceneFileType &A3DSSceneFileType::the(void)
 128 {
 129     return _the;
 130 }
 131
 132
 133 const Char8 *A3DSSceneFileType::getName(void) const
 134 {
 135     return "3DS Geometry";
 136 }
 137
 138
 139 A3DSSceneFileType::A3DSSceneFileType(const A3DSSceneFileType &obj) :
 140     SceneFileType(obj),
 141     _materials()
 142 {
 143     return;
 144 }
 145
 146
 147 A3DSSceneFileType::~A3DSSceneFileType (void )
 148 {
 149     return;
 150 }
 151
 152 NodeTransitPtr A3DSSceneFileType::createMesh(L3DS &scene, LMesh &mesh) const
 153 {
 154     if(mesh.GetTriangleCount() == 0)
 155         return NodeTransitPtr(NULL);
 156
 157     NodeUnrecPtr     node = Node::create();
 158     GeometryUnrecPtr geo = Geometry::create();
 159
 160     node->setCore(geo);
 161
 162     OSG::setName(node, mesh.GetName().c_str());
 163
 164     GeoPnt3fPropertyUnrecPtr points    = GeoPnt3fProperty::create();
 165     GeoVec3fPropertyUnrecPtr normals   = GeoVec3fProperty::create();
 166     GeoVec2fPropertyUnrecPtr texcoords = GeoVec2fProperty::create();
 167
 168     for(UInt32 i=0;i<mesh.GetTriangleCount();++i)
 169     {
 170         const LTriangle2 &t = mesh.GetTriangle2(i);
 171
 172         points->push_back(Pnt3f(t.vertices[0].x,
 173                                 t.vertices[0].y,
 174                                 t.vertices[0].z));
 175
 176         points->push_back(Pnt3f(t.vertices[1].x,
 177                                 t.vertices[1].y,
 178                                 t.vertices[1].z));
 179
 180         points->push_back(Pnt3f(t.vertices[2].x,
 181                                 t.vertices[2].y,
 182                                 t.vertices[2].z));
 183
 184         normals->push_back(Vec3f(t.vertexNormals[0].x,
 185                                  t.vertexNormals[0].y,
 186                                  t.vertexNormals[0].z));
 187
 188         normals->push_back(Vec3f(t.vertexNormals[1].x,
 189                                  t.vertexNormals[1].y,
 190                                  t.vertexNormals[1].z));
 191
 192         normals->push_back(Vec3f(t.vertexNormals[2].x,
 193                                  t.vertexNormals[2].y,
 194                                  t.vertexNormals[2].z));
 195
 196         texcoords->push_back(Vec2f(t.textureCoords[0].x, t.textureCoords[0].y));
 197         texcoords->push_back(Vec2f(t.textureCoords[1].x, t.textureCoords[1].y));
 198         texcoords->push_back(Vec2f(t.textureCoords[2].x, t.textureCoords[2].y));
 199     }
 200
 201     // create material opensg supports only one material per geometry!
 202     MaterialUnrecPtr mat = OSG::getDefaultMaterial();
 203
 204     if(mesh.GetMaterialCount() > 0)
 205         mat = createMaterial(scene, mesh.GetMaterial(0));
 206
 207     int nv = mesh.GetTriangleCount() * 3;
 208
 209     GeoUInt32PropertyUnrecPtr indices = GeoUInt32Property::create();
 210
 211     indices->editFieldPtr()->reserve(nv);
 212
 213     for (int i = 0; i < nv; ++i)
 214         indices->push_back(i);
 215
 216     GeoUInt32PropertyUnrecPtr lengths = GeoUInt32Property::create();
 217
 218     lengths->push_back(nv);
 219
 220     GeoUInt8PropertyUnrecPtr types = GeoUInt8Property::create();
 221     types->push_back(GL_TRIANGLES);
 222
 223     geo->setMaterial(mat);
 224     geo->setPositions(points);
 225     geo->setNormals(normals);
 226     geo->setTexCoords(texcoords);
 227     geo->setIndices(indices);
 228     geo->setLengths(lengths);
 229     geo->setTypes(types);
 230
 231     //createSharedIndex(geo);
 232     //OSG::calcVertexNormals(geo);
 233
 234     return NodeTransitPtr(node);
 235 }
 236
 237 MaterialTransitPtr A3DSSceneFileType::createMaterial(L3DS   &scene,
 238                                                      UInt32  id   ) const
 239 {
 240     materialIt mi = _materials.find(id);
 241
 242     if(mi != _materials.end())
 243         return MaterialTransitPtr((*mi).second);
 244
 245     LMaterial m = scene.GetMaterial(id);
 246
 247     ChunkMaterialUnrecPtr cmat = ChunkMaterial::create();
 248
 249     OSG::setName(cmat, m.GetName());
 250
 251     MaterialChunkUnrecPtr matc = MaterialChunk::create();
 252
 253     cmat->addChunk(matc);
 254
 255     Real32 t = m.GetTransparency();
 256
 257     matc->setAmbient(Color4f(m.GetAmbientColor().r, m.GetAmbientColor().g,
 258                      m.GetAmbientColor().b, 1.0f - t));
 259     matc->setDiffuse(Color4f(m.GetDiffuseColor().r, m.GetDiffuseColor().g,
 260                      m.GetDiffuseColor().b, 1.0f - t));
 261     matc->setSpecular(Color4f(m.GetSpecularColor().r, m.GetSpecularColor().g,
 262                      m.GetSpecularColor().b, 1.0f - t));
 263     matc->setEmission(Color4f(0.0f, 0.0f, 0.0f, 1.0f - t));
 264     matc->setShininess(m.GetShininess() * 128.0f);
 265
 266
 267     // create a texture chunk
 268     LMap &map = m.GetTextureMap1();
 269     const char *texname = map.mapName;
 270
 271     ImageUnrecPtr image = NULL;
 272
 273     if(texname != NULL && strlen(texname) > 0)
 274     {
 275         image = Image::create();
 276         bool img_ok = image->read(texname);
 277
 278         if(!img_ok)
 279         {
 280             std::string casename(texname);
 281             for(std::string::reverse_iterator it = casename.rbegin();
 282                 it != casename.rend() && *it != '/' && *it != '\\';
 283                 ++it)
 284             {
 285                 if(*it >= 'a' && *it <= 'z')
 286                 {
 287                     *it = 'A' + *it - 'a';
 288                 }
 289                 else
 290                 if(*it >= 'A' && *it <= 'Z')
 291                 {
 292                     *it = 'a' + *it - 'A';
 293                 }
 294
 295             }
 296
 297             FWARNING(("Couldn't load image '%s', trying case "
 298                       "reversed version '%s'! \n", texname,
 299                       casename.c_str()));
 300
 301             img_ok = image->read(casename.c_str());
 302         }
 303
 304         if(img_ok)
 305         {
 306             image->setForceAlphaBinary(image->calcIsAlphaBinary());
 307
 308             TextureObjChunkUnrecPtr texc  = TextureObjChunk::create();
 309             TextureEnvChunkUnrecPtr texec = TextureEnvChunk::create();
 310
 311             texc->setImage(image);
 312
 313             // 0x0008 means no tiling.
 314             GLenum wm = (map.tiling & 0x0008) ? GL_CLAMP_TO_EDGE : GL_REPEAT;
 315             texc->setWrapS(wm);
 316             texc->setWrapT(wm);
 317
 318             texec->setEnvMode(GL_MODULATE);
 319             texc ->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
 320             texc ->setMagFilter(GL_LINEAR);
 321
 322             cmat->addChunk(texc);
 323             cmat->addChunk(texec);
 324         }
 325     }
 326
 327     // add a blend chunk for transparency
 328     if(t > 0.0 ||
 329        ( image != NULL &&
 330          image->hasAlphaChannel()) )
 331     {
 332         BlendChunkUnrecPtr blendc = BlendChunk::create();
 333
 334         if(image != NULL && image->isAlphaBinary())
 335         {
 336             blendc->setAlphaFunc(GL_NOTEQUAL);
 337             blendc->setAlphaValue(0);
 338         }
 339         else
 340         {
 341             blendc->setSrcFactor(GL_SRC_ALPHA);
 342             blendc->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
 343         }
 344
 345         cmat->addChunk(blendc);
 346     }
 347
 348     _materials.insert(std::pair<UInt32, MaterialUnrecPtr>(
 349                           id, MaterialUnrecPtr(cmat)));
 350
 351     return MaterialTransitPtr(cmat);
 352 }