tiny_render/Model.cpp at main · YeonSeong-Lee/tiny_render · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include "Model.hpp"

#include <fstream>
#include <iostream>
#include <sstream>

Model::Model(const char *filename)
    : verts_(),
      faces_(),
      norms_(),
      uv_(),
      diffusemap_(),
      normalmap_(),
      specularmap_() {
  std::ifstream in;
  in.open(filename, std::ifstream::in);
  if (in.fail()) return;
  std::string line;
  while (!in.eof()) {
    std::getline(in, line);
    std::istringstream iss(line.c_str());
    char trash;
    if (!line.compare(0, 2, "v ")) {
      iss >> trash;
      Vec3f v;
      for (int i = 0; i < 3; i++) iss >> v[i];
      verts_.push_back(v);
    } else if (!line.compare(0, 3, "vn ")) {
      iss >> trash >> trash;
      Vec3f n;
      for (int i = 0; i < 3; i++) iss >> n[i];
      norms_.push_back(n);
    } else if (!line.compare(0, 3, "vt ")) {
      iss >> trash >> trash;
      Vec2f uv;
      for (int i = 0; i < 2; i++) iss >> uv[i];
      uv_.push_back(uv);
    } else if (!line.compare(0, 2, "f ")) {
      std::vector<Vec3i> f;
      Vec3i tmp;
      iss >> trash;
      while (iss >> tmp[0] >> trash >> tmp[1] >> trash >> tmp[2]) {
        for (int i = 0; i < 3; i++)
          tmp[i]--;  // in wavefront obj all indices start at 1, not zero
        f.push_back(tmp);
      }
      faces_.push_back(f);
    }
  }
  std::cerr << "# v# " << verts_.size() << " f# " << faces_.size() << " vt# "
            << uv_.size() << " vn# " << norms_.size() << std::endl;
  load_texture(filename, "_diffuse.tga", diffusemap_);
  load_texture(filename, "_nm.tga", normalmap_);
  load_texture(filename, "_spec.tga", specularmap_);
}

Model::~Model() {}

int Model::nverts() { return (int)verts_.size(); }

int Model::nfaces() { return (int)faces_.size(); }

std::vector<int> Model::face(int idx) {
  std::vector<int> face;
  for (int i = 0; i < (int)faces_[idx].size(); i++)
    face.push_back(faces_[idx][i][0]);
  return face;
}

Vec3f Model::vert(int i) { return verts_[i]; }

Vec3f Model::vert(int iface, int nthvert) {
  return verts_[faces_[iface][nthvert][0]];
}

void Model::load_texture(std::string filename, const char *suffix,
                         TGAImage &img) {
  std::string texfile(filename);
  size_t dot = texfile.find_last_of(".");
  if (dot != std::string::npos) {
    texfile = texfile.substr(0, dot) + std::string(suffix);
    std::cerr << "texture file " << texfile << " loading "
              << (img.read_tga_file(texfile.c_str()) ? "ok" : "failed")
              << std::endl;
    img.flip_vertically();
  }
}

TGAColor Model::diffuse(Vec2f uvf) {
  Vec2i uv(uvf[0] * diffusemap_.get_width(), uvf[1] * diffusemap_.get_height());
  return diffusemap_.get(uv[0], uv[1]);
}

Vec3f Model::normal(Vec2f uvf) {
  Vec2i uv(uvf[0] * normalmap_.get_width(), uvf[1] * normalmap_.get_height());
  TGAColor c = normalmap_.get(uv[0], uv[1]);
  Vec3f res;
  for (int i = 0; i < 3; i++) res[2 - i] = (float)c[i] / 255.f * 2.f - 1.f;
  return res;
}

Vec2f Model::uv(int iface, int nthvert) {
  return uv_[faces_[iface][nthvert][1]];
}

float Model::specular(Vec2f uvf) {
  Vec2i uv(uvf[0] * specularmap_.get_width(),
           uvf[1] * specularmap_.get_height());
  return specularmap_.get(uv[0], uv[1])[0] / 1.f;
}

Vec3f Model::normal(int iface, int nthvert) {
  int idx = faces_[iface][nthvert][2];
  return norms_[idx].normalize();
}