L3DS Class Reference

01126 : LImporter()
01127 {
01128     m_buffer = 0;
01129     m_bufferSize = 0;
01130     m_pos = 0;
01131     m_eof = false;
01132 }

01135 : LImporter()
01136 {
01137     m_buffer = 0;
01138     m_bufferSize = 0;
01139     m_pos = 0;
01140     m_eof = false;
01141     Load(filename);
01142 }

01145 {
01146     if (m_bufferSize > 0)
01147         free(m_buffer);
01148 }

01151 {
01152     // get length of file:
01153     is.seekg(0, std::ios::end);
01154     m_bufferSize = is.tellg();
01155     is.seekg(0, std::ios::beg);
01156 
01157     m_buffer = (unsigned char*) calloc(m_bufferSize, 1);
01158     if (m_buffer == 0)
01159     {
01160         fprintf(stderr, "L3DS::LoadFile - not enough memory (malloc failed)");
01161         return false;
01162     }
01163     is.read((char *) m_buffer, m_bufferSize);
01164     if(is.gcount() != m_bufferSize)
01165     {
01166         free(m_buffer);
01167         m_bufferSize = 0;
01168         fprintf(stderr, "L3DS::LoadFile - error reading from stream");
01169         return false;
01170     }
01171 
01172     Clear();
01173     bool res = Read3DS();
01174     free(m_buffer);
01175     m_buffer = 0;
01176     m_bufferSize = 0;
01177     return res;
01178 }

01181 {
01182     FILE *f;
01183     f = fopen(filename, "rb");
01184     if (f == 0)
01185     {
01186         fprintf(stderr, "L3DS::LoadFile - cannot open file");
01187         return false;
01188     }
01189     fseek(f, 0, SEEK_END);
01190     m_bufferSize = ftell(f);
01191     fseek(f, 0, SEEK_SET);
01192     m_buffer = (unsigned char*) calloc(m_bufferSize, 1);
01193     if (m_buffer == 0)
01194     {
01195         fprintf(stderr, "L3DS::LoadFile - not enough memory (malloc failed)");
01196         return false;
01197     }
01198     if (fread(m_buffer, m_bufferSize, 1, f) != 1)
01199     {
01200         fclose(f);
01201         free(m_buffer);
01202         m_bufferSize = 0;
01203         fprintf(stderr, "L3DS::LoadFile - error reading from file");
01204         return false;
01205     }
01206     fclose(f);
01207 
01208     Clear();
01209     bool res = Read3DS();
01210     free(m_buffer);
01211     m_buffer = 0;
01212     m_bufferSize = 0;
01213     return res;
01214 }

01217 {
01218     if ((m_buffer!=0) && (m_bufferSize != 0) && ((m_pos+2)<m_bufferSize))
01219     {
01220         short *w = (short*)(m_buffer+m_pos);
01221         short s = *w;//(short)*(m_buffer+m_pos);
01222         m_pos += 2;
01223         return s;
01224     }
01225     m_eof = true;
01226     return 0;
01227 }

01230 {
01231     if ((m_buffer!=0) && (m_bufferSize != 0) && ((m_pos+4)<m_bufferSize))
01232     {
01233         int *w = (int*)(m_buffer+m_pos);
01234         int s = *w;//(int)*(m_buffer+m_pos);
01235         m_pos += 4;
01236         return s;
01237     }
01238     m_eof = true;
01239     return 0;
01240 }

01243 {
01244     if ((m_buffer!=0) && (m_bufferSize != 0) && ((m_pos+1)<m_bufferSize))
01245     {
01246         char s = (char)*(m_buffer+m_pos);
01247         m_pos += 1;
01248         return s;
01249     }
01250     m_eof = true;
01251     return 0;
01252 }

01255 {
01256     if ((m_buffer!=0) && (m_bufferSize != 0) && ((m_pos+4)<m_bufferSize))
01257     {
01258         float *w = (float*)(m_buffer+m_pos);
01259         float s = *w;//(float)*(m_buffer+m_pos);
01260         m_pos += 4;
01261         return s;
01262     }
01263     m_eof = true;
01264     return 0.0;
01265 }

01268 {
01269     if ((m_buffer!=0) && (m_bufferSize != 0) && ((m_pos+1)<m_bufferSize))
01270     {
01271         byte s = (byte)*(m_buffer+m_pos);
01272         m_pos += 1;
01273         return s;
01274     }
01275     m_eof = true;
01276     return 0;
01277 }

01280 {
01281     int count;
01282     if ((m_buffer==0) || (m_bufferSize == 0) || (m_pos>=m_bufferSize))
01283     {
01284         count = 0;
01285         m_eof = true;
01286         return count;
01287     }
01288     count = 0;
01289     char c = ReadChar();
01290     while ((c!=0) && (count<max_count-1))
01291     {
01292         buf[count] = c;
01293         count ++;
01294         c = ReadChar();
01295     }
01296     buf[count] = 0;
01297     return count;
01298 }

01301 {
01302     if (origin == SEEK_START)
01303         m_pos = offset;
01304     if (origin == SEEK_CURSOR)
01305         m_pos += offset;
01306     if (static_cast<signed>(m_pos) < 0)
01307         m_pos = 0;
01308     if (m_pos >= m_bufferSize)
01309         m_pos = m_bufferSize-1;
01310     m_eof = false;
01311 }

01314 {
01315     return m_pos;
01316 }

01319 {
01320     LChunk chunk;
01321     chunk.id = ReadShort();
01322     int a = ReadInt();
01323     chunk.start = Pos();
01324     chunk.end = chunk.start+a-6;
01325     return chunk;
01326 }

01329 {
01330     if (Pos() >= parent.end)
01331         return false;
01332     LChunk chunk;
01333     chunk = ReadChunk();
01334     while (( chunk.id != target.id) && (chunk.end <= parent.end))
01335     {
01336         SkipChunk(chunk);
01337         if (chunk.end >= parent.end)
01338             break;
01339         unsigned short id = chunk.id;
01340         uint end = chunk.end;
01341         chunk = ReadChunk();
01342         // try to detect a endless loop amz
01343         if(id == chunk.id && end == chunk.end)
01344             break;
01345     }
01346     if (chunk.id == target.id)
01347     {
01348         target.start = chunk.start;
01349         target.end = chunk.end;
01350         return true;
01351     }
01352     return false;
01353 }

01356 {
01357     Seek(chunk.end, SEEK_START);
01358 }

01361 {
01362     Seek(chunk.start, SEEK_START);
01363 }

01366 {
01367     LColor3 col = black;
01368     GotoChunk(chunk);
01369     switch (chunk.id)
01370     {
01371     case COLOR_F:
01372         col.r = ReadFloat();
01373         col.g = ReadFloat();
01374         col.b = ReadFloat();
01375         break;
01376     case COLOR_24:
01377         col.r = ReadByte()/255.0f;
01378         col.g = ReadByte()/255.0f;
01379         col.b = ReadByte()/255.0f;
01380         break;
01381     case LIN_COLOR_F:
01382         col.r = ReadFloat();
01383         col.g = ReadFloat();
01384         col.b = ReadFloat();
01385         break;
01386     case LIN_COLOR_24:
01387         col.r = ReadByte()/255.0f;
01388         col.g = ReadByte()/255.0f;
01389         col.b = ReadByte()/255.0f;
01390         break;
01391     default:
01392         fprintf(stderr, "L3DS::ReadColor - error this is not a color chunk");
01393     }
01394     return col;
01395 }

01398 {
01399     GotoChunk(chunk);
01400     switch (chunk.id)
01401     {
01402     case INT_PERCENTAGE:
01403         return (ReadShort()/100.0f);
01404     case FLOAT_PERCENTAGE:
01405         return ReadFloat();
01406     }
01407     fprintf(stderr, "L3DS::ReadPercentage - error, the chunk is not a percentage chunk");
01408     return 0;
01409 }

01412 {
01413     LChunk mainchunk;
01414     LChunk edit;
01415     edit.id = EDIT3DS;
01416     mainchunk = ReadChunk();
01417     if (mainchunk.id != MAIN3DS)
01418     {
01419         fprintf(stderr, "L3DS::Read3DS - wrong file format");
01420         return false;
01421     }
01422     if (!FindChunk(edit, mainchunk))
01423         return false;
01424     LChunk obj;
01425     LChunk ml;
01426 
01427     GotoChunk(edit);
01428     obj.id = MAT_ENTRY;
01429     while (FindChunk(obj, edit))
01430     {
01431         ReadMaterial(obj);
01432         SkipChunk(obj);
01433     }
01434     GotoChunk(edit);
01435 
01436     obj.id = EDIT_OBJECT;
01437     {
01438         while (FindChunk(obj, edit))
01439         {
01440             ReadASCIIZ(m_objName, 99);
01441             ml = ReadChunk();
01442             if (ml.id == OBJ_TRIMESH)
01443                 ReadMesh(ml);
01444             else
01445             if (ml.id == OBJ_LIGHT)
01446                 ReadLight(ml);
01447             else
01448             if (ml.id == OBJ_CAMERA)
01449                 ReadCamera(ml);
01450             SkipChunk(obj);
01451         }
01452     }
01453 
01454     // read the keyframer data here to find out correct object orientation
01455 
01456     LChunk keyframer;
01457     keyframer.id = KFDATA;
01458 
01459     LChunk objtrack;
01460     objtrack.id = OBJECT_NODE_TAG;
01461 
01462     GotoChunk(mainchunk);
01463     if (FindChunk(keyframer, mainchunk))
01464     {   // keyframer chunk is present
01465         GotoChunk(keyframer);
01466         while (FindChunk(objtrack, keyframer))
01467         {
01468             ReadKeyframeData(objtrack);
01469             SkipChunk(objtrack);
01470         }
01471     }
01472 
01473     for (uint i=0; i<m_meshes.size(); i++)
01474         m_meshes[i].Optimize(m_optLevel);
01475     m_pos = 0;
01476     strcpy(m_objName, "");
01477     return true;
01478 }

01481 {
01482     float t;
01483     LVector3 v;
01484     LLight light;
01485     light.SetName(m_objName);
01486     v.x = ReadFloat();
01487     v.y = ReadFloat();
01488     v.z = ReadFloat();
01489     light.SetPosition(v);
01490     LChunk chunk = ReadChunk();
01491     while (chunk.end <= parent.end)
01492     {
01493         switch (chunk.id)
01494         {
01495         case COLOR_24:
01496         case COLOR_F:
01497         case LIN_COLOR_F:
01498         case LIN_COLOR_24:
01499             light.SetColor(ReadColor(chunk));
01500             break;
01501         case SPOTLIGHT:
01502             v.x = ReadFloat();
01503             v.y = ReadFloat();
01504             v.z = ReadFloat();
01505             light.SetTarget(v);
01506             t = ReadFloat();
01507             light.SetHotspot(t);
01508             t = ReadFloat();
01509             light.SetFalloff(t);
01510             break;
01511         case LIT_INRANGE:
01512             light.SetAttenuationstart(ReadFloat());
01513             break;
01514         case LIT_OUTRANGE:
01515             light.SetAttenuationend(ReadFloat());
01516             break;
01517         default:
01518             break;
01519         }
01520         SkipChunk(chunk);
01521         if (chunk.end >= parent.end)
01522             break;
01523         chunk = ReadChunk();
01524 
01525     }
01526     m_lights.push_back(light);
01527 }

01530 {
01531     LVector3 v,t;
01532     LCamera camera;
01533     camera.SetName(m_objName);
01534     v.x = ReadFloat();
01535     v.y = ReadFloat();
01536     v.z = ReadFloat();
01537     t.x = ReadFloat();
01538     t.y = ReadFloat();
01539     t.z = ReadFloat();
01540     camera.SetPosition(v);
01541     camera.SetTarget(t);
01542     camera.SetBank(ReadFloat());
01543     camera.SetFOV(2400.0f/ReadFloat());
01544     LChunk chunk = ReadChunk();
01545     while (chunk.end <= parent.end)
01546     {
01547         switch (chunk.id)
01548         {
01549         case CAM_RANGES:
01550             camera.SetNearplane(ReadFloat());
01551             camera.SetFarplane(ReadFloat());
01552             break;
01553         default:
01554             break;
01555         }
01556         SkipChunk(chunk);
01557         if (chunk.end >= parent.end)
01558             break;
01559         chunk = ReadChunk();
01560 
01561     }
01562     m_cameras.push_back(camera);
01563 }

01566 {
01567     unsigned short count, i;
01568     LVector4 p;
01569     LMatrix4 m;
01570     LVector2 t;
01571     p.w = 1.0f;
01572     LMesh mesh;
01573     mesh.SetName(m_objName);
01574     GotoChunk(parent);
01575     LChunk chunk = ReadChunk();
01576     while (chunk.end <= parent.end)
01577     {
01578         switch (chunk.id)
01579         {
01580         case TRI_VERTEXLIST:
01581             count = ReadShort();
01582             mesh.SetVertexArraySize(count);
01583             for (i=0; i < count; i++)
01584             {
01585                 p.x = ReadFloat();
01586                 p.y = ReadFloat();
01587                 p.z = ReadFloat();
01588                 mesh.SetVertex(p, i);
01589             }
01590             break;
01591         case TRI_FACEMAPPING:
01592             count = ReadShort();
01593             if (mesh.GetVertexCount() == 0)
01594                 mesh.SetVertexArraySize(count);
01595             for (i=0; i < count; i++)
01596             {
01597                 t.x = ReadFloat();
01598                 t.y = ReadFloat();
01599                 mesh.SetUV(t, i);
01600             }
01601             break;
01602         case TRI_FACELIST:
01603             ReadFaceList(chunk, mesh);
01604             break;
01605         case TRI_MATRIX:
01606             m._11 = ReadFloat();
01607             m._12 = ReadFloat();
01608             m._13 = ReadFloat();
01609 
01610             m._21 = ReadFloat();
01611             m._22 = ReadFloat();
01612             m._23 = ReadFloat();
01613 
01614             m._31 = ReadFloat();
01615             m._32 = ReadFloat();
01616             m._33 = ReadFloat();
01617 
01618             m._41 = ReadFloat();
01619             m._42 = ReadFloat();
01620             m._43 = ReadFloat();
01621 
01622             m._14 = 0.0f;
01623             m._24 = 0.0f;
01624             m._34 = 0.0f;
01625             m._44 = 1.0f;
01626 
01627             mesh.SetMatrix(m);
01628             break;
01629         default:
01630             break;
01631         }
01632         SkipChunk(chunk);
01633         if (chunk.end >= parent.end)
01634             break;
01635         chunk = ReadChunk();
01636     }
01637     m_meshes.push_back(mesh);
01638 }

01641 {
01642     // variables
01643     unsigned short count, t;
01644     uint i;
01645     LTri tri;
01646     LChunk ch;
01647     char str[20];
01648     //uint mat;
01649 
01650     // consistency checks
01651     if (chunk.id != TRI_FACELIST)
01652     {
01653         fprintf(stderr, "L3DS::ReadFaceList - internal error: wrong chunk passed as parameter");
01654         return;
01655     }
01656     GotoChunk(chunk);
01657     tri.smoothingGroups = 1;
01658     // read the number of faces
01659     count = ReadShort();
01660     mesh.SetTriangleArraySize(count);
01661     for (i=0; i<count; i++)
01662     {
01663         tri.a = ReadShort();
01664         tri.b = ReadShort();
01665         tri.c = ReadShort();
01666         ReadShort();
01667         mesh.SetTri(tri, i);
01668     }
01669     // now read the optional chunks
01670     ch = ReadChunk();
01671     int mat_id;
01672     while (ch.end <= chunk.end)
01673     {
01674         switch (ch.id)
01675         {
01676         case TRI_MAT_GROUP:
01677             ReadASCIIZ(str, 20);
01678             mat_id = FindMaterial(str)->GetID();
01679             mesh.AddMaterial(mat_id);
01680             count = ReadShort();
01681             for (i=0; i<count; i++)
01682             {
01683                 t = ReadShort();
01684                 mesh.GetTri(t).materialId = mat_id;
01685             }
01686             break;
01687         case TRI_SMOOTH_GROUP:
01688             for (i=0; i<mesh.GetTriangleCount(); i++)
01689                 mesh.GetTri(i).smoothingGroups = (ulong) ReadInt();
01690