Ignore:
Timestamp:
01/05/09 16:48:21 (16 years ago)
Author:
mattausch
Message:

worked on obj loader
played around with ssao sampling

Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling/Converter
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/Converter/ObjConverter.cpp

    r3246 r3247  
    154154void ObjConverter::LoadShape(const VertexArray &faceVertices, 
    155155                                                         const VertexArray &faceNormals, 
    156                                                          const vector<Texcoord> &faceTexcoords) 
     156                                                         const vector<Texcoord> &faceTexcoords, 
     157                                                         Material *mat) 
    157158{ 
    158159        int numElements = (int)faceVertices.size(); 
     
    167168        geom->mTexcoordCount = (int)faceTexcoords.size(); 
    168169 
    169         cout << "number of vertices=" << numElements << endl; 
     170        geom->mMaterial = mat; 
     171 
     172        cout << "new geometry #vts=" << numElements << endl; 
    170173 
    171174        for (int i = 0; i < numElements; ++ i) 
     
    244247        } 
    245248         
     249        Material *currentMat = NULL; 
    246250        VertexArray faceVertices;  
    247251        VertexArray faceNormals; 
     
    279283                                        sscanf(str + 1, "%f %f %f", &x, &y, &z); 
    280284                                        //const float scale = 5e-3f; 
    281                                         const float scale = 1.0f; 
     285                                        const float scale = 5.0f; 
    282286                                        vertices.push_back(SimpleVec(x * scale, y * scale, z* scale)); 
    283287                                        //cout <<"v " << x << " " << y << " "<< z << " "; 
     
    294298                                                faceVertices, faceNormals, faceTexcoords); 
    295299 
    296                                 if (0 && 
    297                                         (((line % 1000) == 999) && !faceVertices.empty())) 
     300                                break; 
     301                        }   // end face 
     302                case 'g': // load a new shape 
     303                        { 
     304                                if (!faceVertices.empty()) 
    298305                                { 
    299306                                        ++ mNumShapes; 
    300307 
    301                                         LoadShape(faceVertices, faceNormals, faceTexcoords); 
     308                                        LoadShape(faceVertices, faceNormals, faceTexcoords, currentMat); 
    302309 
    303310                                        faceVertices.clear(); 
    304311                                        faceNormals.clear(); 
    305312                                        faceTexcoords.clear(); 
     313 
     314                                        currentMat = NULL; 
    306315                                } 
    307  
    308                                 break; 
    309                         }   // end face 
    310                 case 'g': // load a new shape 
    311                         {/* 
    312                                 if (!faceVertices.empty()) 
    313                                 { 
    314                                         ++ mNumShapes; 
    315  
    316                                         LoadShape(faceVertices, faceNormals, faceTexcoords); 
    317  
    318                                         faceVertices.clear(); 
    319                                         faceNormals.clear(); 
    320                                         faceTexcoords.clear(); 
    321                                 }*/ 
    322                         } 
     316                        } 
     317                        break; 
     318                case 'u': // usemtl => material 
     319                        { 
     320                                string matName(str + 7); 
     321                                // throw away linebreak character 
     322                                matName.resize(matName.size() - 1); 
     323 
     324                                currentMat = mMaterialTable[matName]; 
     325                                cout << "matname: " << matName << endl; 
     326                        } 
     327 
    323328                        break; 
    324329                default: 
     
    334339                ++ mNumShapes; 
    335340 
    336                 LoadShape(faceVertices, faceNormals, faceTexcoords); 
     341                LoadShape(faceVertices, faceNormals, faceTexcoords, currentMat); 
    337342 
    338343                faceVertices.clear(); 
     
    364369        /////// 
    365370        //-- texture 
    366  
     371/* 
    367372#ifdef USE_TEXTURE 
    368373        int texId = 0; 
     
    401406                str.write(reinterpret_cast<char *>(&emm), sizeof(SimpleVec)); 
    402407        } 
    403 } 
    404  
    405  
     408*/ 
     409} 
     410 
     411#if 0 
    406412bool ObjConverter::WriteFile(const string &filename) 
    407413{ 
     
    481487        return true; 
    482488} 
     489#else 
     490bool ObjConverter::WriteFile(const string &filename) 
     491{ 
     492        ogzstream ofile(filename.c_str()); 
     493 
     494        if (!ofile.is_open()) 
     495                return false; 
     496         
     497 
     498        ///////// 
     499        //-- write textures 
     500 
     501        int textureCount = (int)mTextures.size(); 
     502 
     503        ofile.write(reinterpret_cast<char *>(&textureCount), sizeof(int)); 
     504 
     505        TextureArray::const_iterator tit, tit_end = mTextures.end(); 
     506         
     507        for (tit = mTextures.begin(); tit != tit_end; ++ tit) 
     508        { 
     509                const string texName = (*tit); 
     510 
     511                int texnameSize = (int)texName.length() + 1; 
     512                ofile.write(reinterpret_cast<char *>(&texnameSize), sizeof(int)); 
     513 
     514                ofile.write(texName.c_str(), sizeof(char) * texnameSize); 
     515 
     516                int boundS = 1, boundT = 1; 
     517 
     518                ofile.write(reinterpret_cast<char *>(&boundS), sizeof(int)); 
     519                ofile.write(reinterpret_cast<char *>(&boundT), sizeof(int)); 
     520        } 
     521 
     522 
     523        /////////// 
     524        //-- write shapes 
     525 
     526        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int)); 
     527 
     528        vector<Geometry *>::const_iterator it, it_end = mGeometry.end(); 
     529 
     530        for (it = mGeometry.begin(); it != it_end; ++ it) 
     531        { 
     532                WriteGeometry(ofile, *it); 
     533 
     534                 
     535                ///////// 
     536                //-- material 
     537 
     538                Material *mat = (*it)->mMaterial; 
     539 
     540                ofile.write(reinterpret_cast<char *>(&mat->texture), sizeof(int)); 
     541 
     542                bool alphaTestEnabled = false; 
     543                //bool cullFaceEnabled = false; 
     544                bool cullFaceEnabled = true; 
     545                 
     546                ofile.write(reinterpret_cast<char *>(&alphaTestEnabled), sizeof(bool)); 
     547                ofile.write(reinterpret_cast<char *>(&cullFaceEnabled), sizeof(bool)); 
     548 
     549                // material 
     550                bool hasMaterial = true; 
     551                ofile.write(reinterpret_cast<char *>(&hasMaterial), sizeof(bool)); 
     552         
     553                SimpleVec ambient, diffuse, spec, emm; 
     554 
     555                ambient.x = ambient.y = ambient.z = 0.2f; 
     556                //diffuse.x = diffuse.y = diffuse.z = 1.0f; 
     557                diffuse.x = mat->rgb[0]; diffuse.y =mat->rgb[1]; diffuse.z = mat->rgb[2]; 
     558                spec.x = spec.y = spec.z = .0f; 
     559                emm = spec; 
     560 
     561                // only write rgb part of the material 
     562                ofile.write(reinterpret_cast<char *>(&ambient), sizeof(SimpleVec)); 
     563                ofile.write(reinterpret_cast<char *>(&diffuse), sizeof(SimpleVec)); 
     564                ofile.write(reinterpret_cast<char *>(&spec), sizeof(SimpleVec)); 
     565                ofile.write(reinterpret_cast<char *>(&emm), sizeof(SimpleVec)); 
     566        } 
     567 
     568 
     569        int entityCount = 1; 
     570        ofile.write(reinterpret_cast<char *>(&entityCount), sizeof(int)); 
     571 
     572 
     573        ////////// 
     574        //-- write single scene entity 
     575 
     576        // no transformation 
     577        bool hasTrafo = false; 
     578        ofile.write(reinterpret_cast<char *>(&hasTrafo), sizeof(bool)); 
     579 
     580        // a dummy lod 
     581        int numLODs = 1; 
     582        ofile.write(reinterpret_cast<char *>(&numLODs), sizeof(int)); 
     583 
     584        float dist = 0; 
     585        ofile.write(reinterpret_cast<char *>(&dist), sizeof(float)); 
     586 
     587        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int)); 
     588 
     589        // all shapes belong to this scene entity 
     590        for (int i = 0; i < mNumShapes; ++ i) 
     591        { 
     592                int shapeId = i; 
     593                ofile.write(reinterpret_cast<char *>(&shapeId), sizeof(int)); 
     594        } 
     595 
     596        return true; 
     597} 
     598#endif 
     599 
     600 
     601bool ObjConverter::LoadMaterials(const std::string &matFileName) 
     602{ 
     603        FILE *file; 
     604 
     605        if ((file = fopen(matFileName.c_str(), "r")) == NULL) 
     606        {        
     607                return false; 
     608        } 
     609         
     610        int line = 0; 
     611        const int len = 10000; 
     612        char str[len]; 
     613 
     614        Material *currentMat = NULL; 
     615 
     616 
     617        while (fgets(str, len, file) != NULL) 
     618        { 
     619                //sscanf(str + 1, "%f %f %f", &x, &y, &z); 
     620                vector<string> strings; 
     621 
     622                char *next_token; 
     623 
     624                // extract the triples of the form v/t/n v/t/n ... 
     625                char *pch = strtok_s(str, " \n", &next_token); 
     626 
     627                while (pch) 
     628                { 
     629                        string s(pch); 
     630                        //s += "\n", 
     631                        strings.push_back(s); 
     632 
     633                        pch = strtok_s(NULL, " \n", &next_token);         
     634                } 
     635 
     636                cout << endl; 
     637 
     638                 
     639                if ((strings.size() == 2) && (strcmp(strings[0].c_str(),"newmtl") == 0)) 
     640                { 
     641                        currentMat = new Material(); 
     642                        mMaterialTable[strings[1].c_str()] = currentMat; 
     643                } 
     644 
     645                if ((strings.size() == 2) && (strcmp(strings[0].c_str(),"map_Kd") == 0)) 
     646                { 
     647                        TextureTable::const_iterator it = mTextureTable.find(strings[1]); 
     648 
     649                        int id; 
     650 
     651                        if (it == mTextureTable.end()) // parameter not found 
     652                        { 
     653                                mTextures.push_back(strings[1]); 
     654                                id = (int)mTextures.size(); 
     655                                mTextureTable[strings[1]] = id; 
     656                        } 
     657                        else 
     658                        { 
     659                                id = (*it).second; 
     660                        } 
     661 
     662                        currentMat->texture = id; 
     663                } 
     664 
     665                if ((strings.size() == 4) && (strcmp(strings[0].c_str(),"Kd") == 0)) 
     666                { 
     667                        currentMat->rgb[0] = (float)atof(strings[1].c_str()); 
     668                        currentMat->rgb[1] = (float)atof(strings[2].c_str()); 
     669                        currentMat->rgb[2] = (float)atof(strings[3].c_str()); 
     670                } 
     671 
     672                ++ line; 
     673        } 
     674 
     675        return true; 
     676} 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/Converter/ObjConverter.h

    r3012 r3247  
    55#include <string> 
    66#include <vector> 
     7#include <map> 
    78 
    8 /*struct SimpleVec 
     9 
     10struct Material 
    911{ 
    10         SimpleVec() {} 
    11         SimpleVec(float _x, float _y, float _z): x(_x), y(_y), z(_z) {} 
     12        float rgb[3]; 
     13        int texture; 
     14}; 
    1215 
    13         float x, y, z; 
    14 };*/ 
     16class Geometry; 
    1517 
    1618typedef std::vector<SimpleVec> VertexArray; 
    1719typedef std::pair<float, float> Texcoord; 
     20typedef std::map<std::string, Material *> MaterialTable; 
     21typedef std::map<std::string, int> TextureTable; 
     22 
     23typedef std::vector<std::string> TextureArray; 
    1824 
    1925class ogzstream; 
     
    2935        bool Convert(const std::string &inputFilename,  
    3036                         const std::string &outputFilename); 
    31         // const std::string textureFilename) const; 
     37                     // const std::string textureFilename) const; 
     38 
     39        bool LoadMaterials(const std::string &matFileName); 
    3240 
    3341        ~ObjConverter(); 
     
    4048                SimpleVec *mNormals; 
    4149                Texcoord *mTexcoords; 
     50                Material *mMaterial; 
    4251 
    4352                int mVertexCount; 
     
    4554        }; 
    4655 
     56typedef std::vector<Geometry *> GeometryArray; 
     57 
    4758        void LoadShape(const VertexArray &faceVertices, 
    4859                           const VertexArray &faceNormals, 
    49                                    const std::vector<Texcoord> &faceTexcoords); 
     60                                   const std::vector<Texcoord> &faceTexcoords,  
     61                                   Material *mat); 
    5062 
    5163        void WriteGeometry(ogzstream &str, Geometry *geom); 
     
    5567 
    5668 
    57         std::vector<Geometry *> mGeometry; 
     69        MaterialTable mMaterialTable; 
     70        TextureTable mTextureTable; 
     71         
     72        TextureArray mTextures; 
     73        GeometryArray mGeometry; 
    5874 
    5975        int mNumShapes; 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/Converter/main.cpp

    r3146 r3247  
    1414 
    1515        cout << "converting obj to dem format" << endl; 
     16         
     17        if (!converter.LoadMaterials(model_path + argv[3])) 
     18        { 
     19                cerr << "loading materials failed" << endl; 
     20 
     21                std::cin.get(); 
     22                exit(0); 
     23        } 
    1624 
    1725        if (!converter.Convert(model_path + argv[1], model_path + argv[2])) 
     
    2230                exit(0); 
    2331        } 
    24         //std::cin.get(); 
     32 
    2533        cout << "conversion successful" << endl; 
     34        cout << "press any key" << std::cin.get(); 
    2635 
    2736        return 0; 
Note: See TracChangeset for help on using the changeset viewer.