model.cpp

#include <fstream>
#include <sstream>
#include <string>
#include "model.h"

Model::Model(const char* fileName){
    std::ifstream f(fileName);
    
    if (f.fail())
        return;

    std::string s;
    while(!f.eof()){
        std::getline(f, s);

        std::stringstream ss(s);
        std::string prefix;
        ss>>prefix;

        if(prefix == "v"){
            vec3f v;
            ss>>v.x>>v.y>>v.z;
            verts.push_back(v);
        }
        
        if(prefix == "vt"){
            vec3f vtx(0, 0, 0);
            ss>>vtx.x>>vtx.y;
            text_verts.push_back(vtx);
        }

        if (prefix == "f") {
            int ver, tex, normal;
            std::vector<int> face_data;
            
            char slash;
            // This loop handles the "f v/t/n v/t/n v/t/n" format
            while(ss>>ver>>slash>>tex>>slash>>normal){ //follow the obj file format
                face_data.push_back(ver-1);
                face_data.push_back(tex-1);
                face_data.push_back(normal-1);
            }

            faces.push_back(face_data);
        }

        if (prefix == "vn"){
            vec3f vn;
            ss>>vn.x>>vn.y>>vn.z;
            norms.push_back(vn);
        }
    }

    auto load_texture = [&fileName](const std::string suffix, TGAImage& img ){
        std::string name(fileName);
        size_t dot = name.find_last_of(".");
        if (dot == std::string::npos)
            return;
        std::string textfile = name.substr(0, dot) + suffix;
        std::cerr << "texture file " << textfile << " loading " << (img.read_tga_file(textfile.c_str())? "ok":"failed")<<std::endl; 
    };

    //load diffuse texture
    load_texture("_diffuse.tga", diffusemap);
    diffusemap.flip_vertically();

    //load normal mapping texture
    load_texture("_nm_tangent.tga", normalmap);
    normalmap.flip_vertically();

    //load specular texture
    load_texture("_spec.tga", specularmap);
    specularmap.flip_vertically();
}


vec2f Model::uv(int iface, int nvert){
    int index = faces[iface][nvert * 3 + 1];
    vec3f v = text_verts[index];
    return vec2f(v.x, v.y);
}

vec3f Model::norm(int iface, int nvert){
    int idx = faces[iface][nvert * 3 + 2];
    vec3f v = norms[idx];
    return vec3f(v.x, v.y, v.z).normalized();
}

TGAColor Model::diffuse (vec2f uv){
    double u = uv.x * diffusemap.get_width();
    double v = uv.y * diffusemap.get_height();
    return diffusemap.get(u, v);
} 

TGAColor Model::normal_Map(vec2f uv){
    double u = uv.x * normalmap.get_width();
    double v = uv.y * normalmap.get_height();
    return normalmap.get(u, v);
}

TGAColor Model::specular(vec2f uv){
    double u = uv.x * specularmap.get_width();
    double v = uv.y * specularmap.get_height();
    return specularmap.get(u, v);
}

Model::~Model(){}

int Model::num_verts(){
    return verts.size();
}

int Model::num_faces(){
    return faces.size();
}

vec3f Model::vert(int i){
    return verts[i];
}

vec3f Model::text_vert(int i){
    return text_verts[i];    
}

std::vector<int> Model::face(int i){
    return faces[i];
}