benkyd/tinyobjloader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Apply clang-format.

Browse Source
This commit is contained in:
Syoyo Fujita
2016-08-12 23:12:46 +09:00
parent 156b47760d
commit 07852e206d
1 changed files with 188 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

362
examples/viewer/viewer.cc
View File

@@ -1,15 +1,15 @@
// //
// Simple .obj viewer(vertex only) // Simple .obj viewer(vertex only)
// //
#include <vector> #include <algorithm>
#include <string> #include <cassert>
#include <cmath>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <limits> #include <limits>
#include <cmath> #include <string>
#include <cassert> #include <vector>
#include <algorithm>
#include <GL/glew.h> #include <GL/glew.h>
@@ -30,8 +30,8 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <windows.h>
#include <mmsystem.h> #include <mmsystem.h>
#include <windows.h>
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
@@ -45,7 +45,7 @@ extern "C" {
#endif #endif
class timerutil { class timerutil {
public: public:
#ifdef _WIN32 #ifdef _WIN32
typedef DWORD time_t; typedef DWORD time_t;
@@ -81,7 +81,7 @@ public:
return (time_t)(t.tv_sec * 1000 + t.tv_usec); return (time_t)(t.tv_sec * 1000 + t.tv_usec);
} }
#else // C timer #else // C timer
// using namespace std; // using namespace std;
typedef clock_t time_t; typedef clock_t time_t;
@@ -96,7 +96,7 @@ public:
#endif #endif
#endif #endif
private: private:
#ifdef _WIN32 #ifdef _WIN32
DWORD t_[2]; DWORD t_[2];
#else #else
@@ -110,7 +110,7 @@ private:
}; };
typedef struct { typedef struct {
GLuint vb; // vertex buffer GLuint vb; // vertex buffer
int numTriangles; int numTriangles;
} DrawObject; } DrawObject;
@@ -155,14 +155,15 @@ void CalcNormal(float N[3], float v0[3], float v1[3], float v2[3]) {
float len2 = N[0] * N[0] + N[1] * N[1] + N[2] * N[2]; float len2 = N[0] * N[0] + N[1] * N[1] + N[2] * N[2];
if (len2 > 0.0f) { if (len2 > 0.0f) {
float len = sqrtf(len2); float len = sqrtf(len2);
N[0] /= len; N[0] /= len;
N[1] /= len; N[1] /= len;
} }
} }
bool LoadObjAndConvert(float bmin[3], float bmax[3], std::vector<DrawObject>& drawObjects, const char* filename) bool LoadObjAndConvert(float bmin[3], float bmax[3],
{ std::vector<DrawObject>* drawObjects,
const char* filename) {
tinyobj::attrib_t attrib; tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials; std::vector<tinyobj::material_t> materials;
@@ -170,21 +171,22 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3], std::vector<DrawObject>& dr
timerutil tm; timerutil tm;
tm.start(); tm.start();
std::string err; std::string err;
bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename, NULL); bool ret =
tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename, NULL);
if (!err.empty()) { if (!err.empty()) {
std::cerr << err << std::endl; std::cerr << err << std::endl;
} }
tm.end(); tm.end();
if (!ret) { if (!ret) {
std::cerr << "Failed to load " << filename << std::endl; std::cerr << "Failed to load " << filename << std::endl;
return false; return false;
} }
printf("Parsing time: %d [ms]\n", tm.msec()); printf("Parsing time: %d [ms]\n", (int)tm.msec());
printf("# of vertices = %d\n", (int)(attrib.vertices.size()) / 3); printf("# of vertices = %d\n", (int)(attrib.vertices.size()) / 3);
printf("# of normals = %d\n", (int)(attrib.normals.size()) / 3); printf("# of normals = %d\n", (int)(attrib.normals.size()) / 3);
@@ -196,102 +198,105 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3], std::vector<DrawObject>& dr
bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max(); bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max();
{ {
for (size_t s = 0; s < shapes.size(); s++) { for (size_t s = 0; s < shapes.size(); s++) {
DrawObject o; DrawObject o;
std::vector<float> vb; // pos(3float), normal(3float), color(3float) std::vector<float> vb; // pos(3float), normal(3float), color(3float)
for (size_t f = 0; f < shapes[s].mesh.indices.size()/3; f++) { for (size_t f = 0; f < shapes[s].mesh.indices.size() / 3; f++) {
tinyobj::index_t idx0 = shapes[s].mesh.indices[3 * f + 0];
tinyobj::index_t idx1 = shapes[s].mesh.indices[3 * f + 1];
tinyobj::index_t idx2 = shapes[s].mesh.indices[3 * f + 2];
tinyobj::index_t idx0 = shapes[s].mesh.indices[3*f+0]; float v[3][3];
tinyobj::index_t idx1 = shapes[s].mesh.indices[3*f+1]; for (int k = 0; k < 3; k++) {
tinyobj::index_t idx2 = shapes[s].mesh.indices[3*f+2]; int f0 = idx0.vertex_index;
int f1 = idx1.vertex_index;
int f2 = idx2.vertex_index;
assert(f0 >= 0);
assert(f1 >= 0);
assert(f2 >= 0);
float v[3][3]; v[0][k] = attrib.vertices[3 * f0 + k];
for (int k = 0; k < 3; k++) { v[1][k] = attrib.vertices[3 * f1 + k];
int f0 = idx0.vertex_index; v[2][k] = attrib.vertices[3 * f2 + k];
int f1 = idx1.vertex_index; bmin[k] = std::min(v[0][k], bmin[k]);
int f2 = idx2.vertex_index; bmin[k] = std::min(v[1][k], bmin[k]);
assert(f0 >= 0); bmin[k] = std::min(v[2][k], bmin[k]);
assert(f1 >= 0); bmax[k] = std::max(v[0][k], bmax[k]);
assert(f2 >= 0); bmax[k] = std::max(v[1][k], bmax[k]);
bmax[k] = std::max(v[2][k], bmax[k]);
v[0][k] = attrib.vertices[3*f0+k];
v[1][k] = attrib.vertices[3*f1+k];
v[2][k] = attrib.vertices[3*f2+k];
bmin[k] = std::min(v[0][k], bmin[k]);
bmin[k] = std::min(v[1][k], bmin[k]);
bmin[k] = std::min(v[2][k], bmin[k]);
bmax[k] = std::max(v[0][k], bmax[k]);
bmax[k] = std::max(v[1][k], bmax[k]);
bmax[k] = std::max(v[2][k], bmax[k]);
}
float n[3][3];
if (attrib.normals.size() > 0) {
int f0 = idx0.normal_index;
int f1 = idx1.normal_index;
int f2 = idx2.normal_index;
assert(f0 >= 0);
assert(f1 >= 0);
assert(f2 >= 0);
for (int k = 0; k < 3; k++) {
n[0][k] = attrib.normals[3*f0+k];
n[1][k] = attrib.normals[3*f1+k];
n[2][k] = attrib.normals[3*f2+k];
}
} else {
// compute geometric normal
CalcNormal(n[0], v[0], v[1], v[2]);
n[1][0] = n[0][0]; n[1][1] = n[0][1]; n[1][2] = n[0][2];
n[2][0] = n[0][0]; n[2][1] = n[0][1]; n[2][2] = n[0][2];
}
for (int k = 0; k < 3; k++) {
vb.push_back(v[k][0]);
vb.push_back(v[k][1]);
vb.push_back(v[k][2]);
vb.push_back(n[k][0]);
vb.push_back(n[k][1]);
vb.push_back(n[k][2]);
// Use normal as color.
float c[3] = {n[k][0], n[k][1], n[k][2]};
float len2 = c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
if (len2 > 0.0f) {
float len = sqrtf(len2);
c[0] /= len;
c[1] /= len;
c[2] /= len;
}
vb.push_back(c[0] * 0.5 + 0.5);
vb.push_back(c[1] * 0.5 + 0.5);
vb.push_back(c[2] * 0.5 + 0.5);
}
} }
o.vb = 0; float n[3][3];
o.numTriangles = 0;
if (vb.size() > 0) { if (attrib.normals.size() > 0) {
glGenBuffers(1, &o.vb); int f0 = idx0.normal_index;
glBindBuffer(GL_ARRAY_BUFFER, o.vb); int f1 = idx1.normal_index;
glBufferData(GL_ARRAY_BUFFER, vb.size() * sizeof(float), &vb.at(0), GL_STATIC_DRAW); int f2 = idx2.normal_index;
o.numTriangles = vb.size() / 9 / 3; assert(f0 >= 0);
printf("shape[%d] # of triangles = %d\n", static_cast<int>(s), o.numTriangles); assert(f1 >= 0);
assert(f2 >= 0);
for (int k = 0; k < 3; k++) {
n[0][k] = attrib.normals[3 * f0 + k];
n[1][k] = attrib.normals[3 * f1 + k];
n[2][k] = attrib.normals[3 * f2 + k];
}
} else {
// compute geometric normal
CalcNormal(n[0], v[0], v[1], v[2]);
n[1][0] = n[0][0];
n[1][1] = n[0][1];
n[1][2] = n[0][2];
n[2][0] = n[0][0];
n[2][1] = n[0][1];
n[2][2] = n[0][2];
} }
gDrawObjects.push_back(o); for (int k = 0; k < 3; k++) {
vb.push_back(v[k][0]);
vb.push_back(v[k][1]);
vb.push_back(v[k][2]);
vb.push_back(n[k][0]);
vb.push_back(n[k][1]);
vb.push_back(n[k][2]);
// Use normal as color.
float c[3] = {n[k][0], n[k][1], n[k][2]};
float len2 = c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
if (len2 > 0.0f) {
float len = sqrtf(len2);
c[0] /= len;
c[1] /= len;
c[2] /= len;
}
vb.push_back(c[0] * 0.5 + 0.5);
vb.push_back(c[1] * 0.5 + 0.5);
vb.push_back(c[2] * 0.5 + 0.5);
}
}
o.vb = 0;
o.numTriangles = 0;
if (vb.size() > 0) {
glGenBuffers(1, &o.vb);
glBindBuffer(GL_ARRAY_BUFFER, o.vb);
glBufferData(GL_ARRAY_BUFFER, vb.size() * sizeof(float), &vb.at(0),
GL_STATIC_DRAW);
o.numTriangles = vb.size() / 9 / 3;
printf("shape[%d] # of triangles = %d\n", static_cast<int>(s),
o.numTriangles);
}
drawObjects->push_back(o);
} }
} }
printf("bmin = %f, %f, %f\n", bmin[0], bmin[1], bmin[2]); printf("bmin = %f, %f, %f\n", bmin[0], bmin[1], bmin[2]);
printf("bmax = %f, %f, %f\n", bmax[0], bmax[1], bmax[2]); printf("bmax = %f, %f, %f\n", bmax[0], bmax[1], bmax[2]);
return true; return true;
} }
void reshapeFunc(GLFWwindow* window, int w, int h) void reshapeFunc(GLFWwindow* window, int w, int h) {
{
int fb_w, fb_h; int fb_w, fb_h;
// Get actual framebuffer size. // Get actual framebuffer size.
glfwGetFramebufferSize(window, &fb_w, &fb_h); glfwGetFramebufferSize(window, &fb_w, &fb_h);
@@ -307,78 +312,90 @@ void reshapeFunc(GLFWwindow* window, int w, int h)
height = h; height = h;
} }
void keyboardFunc(GLFWwindow *window, int key, int scancode, int action, int mods) { void keyboardFunc(GLFWwindow* window, int key, int scancode, int action,
if(action == GLFW_PRESS || action == GLFW_REPEAT){ int mods) {
// Move camera (void)window;
float mv_x = 0, mv_y = 0, mv_z = 0; (void)scancode;
if(key == GLFW_KEY_K) mv_x += 1; (void)mods;
else if(key == GLFW_KEY_J) mv_x += -1; if (action == GLFW_PRESS || action == GLFW_REPEAT) {
else if(key == GLFW_KEY_L) mv_y += 1; // Move camera
else if(key == GLFW_KEY_H) mv_y += -1; float mv_x = 0, mv_y = 0, mv_z = 0;
else if(key == GLFW_KEY_P) mv_z += 1; if (key == GLFW_KEY_K)
else if(key == GLFW_KEY_N) mv_z += -1; mv_x += 1;
//camera.move(mv_x * 0.05, mv_y * 0.05, mv_z * 0.05); else if (key == GLFW_KEY_J)
// Close window mv_x += -1;
if(key == GLFW_KEY_Q || key == GLFW_KEY_ESCAPE) glfwSetWindowShouldClose(window, GL_TRUE); else if (key == GLFW_KEY_L)
mv_y += 1;
else if (key == GLFW_KEY_H)
mv_y += -1;
else if (key == GLFW_KEY_P)
mv_z += 1;
else if (key == GLFW_KEY_N)
mv_z += -1;
// camera.move(mv_x * 0.05, mv_y * 0.05, mv_z * 0.05);
// Close window
if (key == GLFW_KEY_Q || key == GLFW_KEY_ESCAPE)
glfwSetWindowShouldClose(window, GL_TRUE);
//init_frame = true; // init_frame = true;
} }
} }
void clickFunc(GLFWwindow* window, int button, int action, int mods){ void clickFunc(GLFWwindow* window, int button, int action, int mods) {
if(button == GLFW_MOUSE_BUTTON_LEFT){ (void)window;
if(action == GLFW_PRESS){ (void)mods;
mouseLeftPressed = true; if (button == GLFW_MOUSE_BUTTON_LEFT) {
trackball(prev_quat, 0.0, 0.0, 0.0, 0.0); if (action == GLFW_PRESS) {
} else if(action == GLFW_RELEASE){ mouseLeftPressed = true;
mouseLeftPressed = false; trackball(prev_quat, 0.0, 0.0, 0.0, 0.0);
} } else if (action == GLFW_RELEASE) {
mouseLeftPressed = false;
} }
if(button == GLFW_MOUSE_BUTTON_RIGHT){ }
if(action == GLFW_PRESS){ if (button == GLFW_MOUSE_BUTTON_RIGHT) {
mouseRightPressed = true; if (action == GLFW_PRESS) {
} else if(action == GLFW_RELEASE){ mouseRightPressed = true;
mouseRightPressed = false; } else if (action == GLFW_RELEASE) {
} mouseRightPressed = false;
} }
if(button == GLFW_MOUSE_BUTTON_MIDDLE){ }
if(action == GLFW_PRESS){ if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
mouseMiddlePressed = true; if (action == GLFW_PRESS) {
} else if(action == GLFW_RELEASE){ mouseMiddlePressed = true;
mouseMiddlePressed = false; } else if (action == GLFW_RELEASE) {
} mouseMiddlePressed = false;
} }
}
} }
void motionFunc(GLFWwindow* window, double mouse_x, double mouse_y){ void motionFunc(GLFWwindow* window, double mouse_x, double mouse_y) {
(void)window;
float rotScale = 1.0f; float rotScale = 1.0f;
float transScale = 2.0f; float transScale = 2.0f;
if(mouseLeftPressed){ if (mouseLeftPressed) {
trackball(prev_quat, trackball(prev_quat, rotScale * (2.0f * prevMouseX - width) / (float)width,
rotScale * (2.0f * prevMouseX - width) / (float)width, rotScale * (height - 2.0f * prevMouseY) / (float)height,
rotScale * (height - 2.0f * prevMouseY) / (float)height, rotScale * (2.0f * mouse_x - width) / (float)width,
rotScale * (2.0f * mouse_x - width) / (float)width, rotScale * (height - 2.0f * mouse_y) / (float)height);
rotScale * (height - 2.0f * mouse_y) / (float)height);
add_quats(prev_quat, curr_quat, curr_quat); add_quats(prev_quat, curr_quat, curr_quat);
} else if (mouseMiddlePressed) { } else if (mouseMiddlePressed) {
eye[0] -= transScale * (mouse_x - prevMouseX) / (float)width; eye[0] -= transScale * (mouse_x - prevMouseX) / (float)width;
lookat[0] -= transScale * (mouse_x - prevMouseX) / (float)width; lookat[0] -= transScale * (mouse_x - prevMouseX) / (float)width;
eye[1] += transScale * (mouse_y - prevMouseY) / (float)height; eye[1] += transScale * (mouse_y - prevMouseY) / (float)height;
lookat[1] += transScale * (mouse_y - prevMouseY) / (float)height; lookat[1] += transScale * (mouse_y - prevMouseY) / (float)height;
} else if (mouseRightPressed) { } else if (mouseRightPressed) {
eye[2] += transScale * (mouse_y - prevMouseY) / (float)height; eye[2] += transScale * (mouse_y - prevMouseY) / (float)height;
lookat[2] += transScale * (mouse_y - prevMouseY) / (float)height; lookat[2] += transScale * (mouse_y - prevMouseY) / (float)height;
} }
// Update mouse point // Update mouse point
prevMouseX = mouse_x; prevMouseX = mouse_x;
prevMouseY = mouse_y; prevMouseY = mouse_y;
} }
void Draw(const std::vector<DrawObject>& drawObjects) void Draw(const std::vector<DrawObject>& drawObjects) {
{
glPolygonMode(GL_FRONT, GL_FILL); glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL); glPolygonMode(GL_BACK, GL_FILL);
@@ -390,14 +407,14 @@ void Draw(const std::vector<DrawObject>& drawObjects)
if (o.vb < 1) { if (o.vb < 1) {
continue; continue;
} }
glBindBuffer(GL_ARRAY_BUFFER, o.vb); glBindBuffer(GL_ARRAY_BUFFER, o.vb);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, 36, (const void*)0); glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float)*3)); glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float) * 3));
glColorPointer(3, GL_FLOAT, 36, (const void*)(sizeof(float)*6)); glColorPointer(3, GL_FLOAT, 36, (const void*)(sizeof(float) * 6));
glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles); glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
CheckErrors("drawarrays"); CheckErrors("drawarrays");
@@ -414,13 +431,13 @@ void Draw(const std::vector<DrawObject>& drawObjects)
if (o.vb < 1) { if (o.vb < 1) {
continue; continue;
} }
glBindBuffer(GL_ARRAY_BUFFER, o.vb); glBindBuffer(GL_ARRAY_BUFFER, o.vb);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, 36, (const void*)0); glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float)*3)); glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float) * 3));
glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles); glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
CheckErrors("drawarrays"); CheckErrors("drawarrays");
@@ -443,26 +460,21 @@ static void Init() {
up[2] = 0.0f; up[2] = 0.0f;
} }
int main(int argc, char** argv) {
int main(int argc, char **argv)
{
if (argc < 2) { if (argc < 2) {
std::cout << "Needs input.obj\n" << std::endl; std::cout << "Needs input.obj\n" << std::endl;
return 0; return 0;
} }
Init(); Init();
if(!glfwInit()){ if (!glfwInit()) {
std::cerr << "Failed to initialize GLFW." << std::endl; std::cerr << "Failed to initialize GLFW." << std::endl;
return -1; return -1;
} }
window = glfwCreateWindow(width, height, "Obj viewer", NULL, NULL); window = glfwCreateWindow(width, height, "Obj viewer", NULL, NULL);
if(window == NULL){ if (window == NULL) {
std::cerr << "Failed to open GLFW window. " << std::endl; std::cerr << "Failed to open GLFW window. " << std::endl;
glfwTerminate(); glfwTerminate();
return 1; return 1;
@@ -486,7 +498,7 @@ int main(int argc, char **argv)
reshapeFunc(window, width, height); reshapeFunc(window, width, height);
float bmin[3], bmax[3]; float bmin[3], bmax[3];
if (false == LoadObjAndConvert(bmin, bmax, gDrawObjects, argv[1])) { if (false == LoadObjAndConvert(bmin, bmax, &gDrawObjects, argv[1])) {
return -1; return -1;
} }
@@ -498,7 +510,7 @@ int main(int argc, char **argv)
maxExtent = 0.5f * (bmax[2] - bmin[2]); maxExtent = 0.5f * (bmax[2] - bmin[2]);
} }
while(glfwWindowShouldClose(window) == GL_FALSE) { while (glfwWindowShouldClose(window) == GL_FALSE) {
glfwPollEvents(); glfwPollEvents();
glClearColor(0.1f, 0.2f, 0.3f, 1.0f); glClearColor(0.1f, 0.2f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -509,7 +521,8 @@ int main(int argc, char **argv)
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
GLfloat mat[4][4]; GLfloat mat[4][4];
gluLookAt(eye[0], eye[1], eye[2], lookat[0], lookat[1], lookat[2], up[0], up[1], up[2]); gluLookAt(eye[0], eye[1], eye[2], lookat[0], lookat[1], lookat[2], up[0],
up[1], up[2]);
build_rotmatrix(mat, curr_quat); build_rotmatrix(mat, curr_quat);
glMultMatrixf(&mat[0][0]); glMultMatrixf(&mat[0][0]);
@@ -517,8 +530,9 @@ int main(int argc, char **argv)
glScalef(1.0f / maxExtent, 1.0f / maxExtent, 1.0f / maxExtent); glScalef(1.0f / maxExtent, 1.0f / maxExtent, 1.0f / maxExtent);
// Centerize object. // Centerize object.
glTranslatef(-0.5*(bmax[0] + bmin[0]), -0.5*(bmax[1] + bmin[1]), -0.5*(bmax[2] + bmin[2])); glTranslatef(-0.5 * (bmax[0] + bmin[0]), -0.5 * (bmax[1] + bmin[1]),
-0.5 * (bmax[2] + bmin[2]));
Draw(gDrawObjects); Draw(gDrawObjects);
glfwSwapBuffers(window); glfwSwapBuffers(window);