pixo 0.1.0

data/ext/pixo/ext/tinyobjloader/examples/callback_api/Makefile

@@ -0,0 +1,2 @@
+all:
+	clang++ -I../../ -Wall -g -o example main.cc

data/ext/pixo/ext/tinyobjloader/examples/callback_api/main.cc

@@ -0,0 +1,166 @@
+//
+// An example of how to use callback API.
+// This example is minimum and incomplete. Just showing the usage of callback
+// API.
+// You need to implement your own Mesh data struct constrution based on this
+// example in practical.
+//
+#define TINYOBJLOADER_IMPLEMENTATION
+#include "tiny_obj_loader.h"
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+typedef struct {
+  std::vector<float> vertices;
+  std::vector<float> normals;
+  std::vector<float> texcoords;
+  std::vector<int> v_indices;
+  std::vector<int> vn_indices;
+  std::vector<int> vt_indices;
+
+  std::vector<tinyobj::material_t> materials;
+
+} MyMesh;
+
+void vertex_cb(void *user_data, float x, float y, float z, float w) {
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+  printf("v[%ld] = %f, %f, %f (w %f)\n", mesh->vertices.size() / 3, x, y, z, w);
+
+  mesh->vertices.push_back(x);
+  mesh->vertices.push_back(y);
+  mesh->vertices.push_back(z);
+  // Discard w
+}
+
+void normal_cb(void *user_data, float x, float y, float z) {
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+  printf("vn[%ld] = %f, %f, %f\n", mesh->normals.size() / 3, x, y, z);
+
+  mesh->normals.push_back(x);
+  mesh->normals.push_back(y);
+  mesh->normals.push_back(z);
+}
+
+void texcoord_cb(void *user_data, float x, float y, float z) {
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+  printf("vt[%ld] = %f, %f, %f\n", mesh->texcoords.size() / 3, x, y, z);
+
+  mesh->texcoords.push_back(x);
+  mesh->texcoords.push_back(y);
+  mesh->texcoords.push_back(z);
+}
+
+void index_cb(void *user_data, tinyobj::index_t *indices, int num_indices) {
+  // NOTE: the value of each index is raw value.
+  // For example, the application must manually adjust the index with offset
+  // (e.g. v_indices.size()) when the value is negative(whic means relative
+  // index).
+  // Also, the first index starts with 1, not 0.
+  // See fixIndex() function in tiny_obj_loader.h for details.
+  // Also, 0 is set for the index value which
+  // does not exist in .obj
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+
+  for (int i = 0; i < num_indices; i++) {
+    tinyobj::index_t idx = indices[i];
+    printf("idx[%ld] = %d, %d, %d\n", mesh->v_indices.size(), idx.vertex_index,
+           idx.normal_index, idx.texcoord_index);
+
+    if (idx.vertex_index != 0) {
+      mesh->v_indices.push_back(idx.vertex_index);
+    }
+    if (idx.normal_index != 0) {
+      mesh->vn_indices.push_back(idx.normal_index);
+    }
+    if (idx.texcoord_index != 0) {
+      mesh->vt_indices.push_back(idx.texcoord_index);
+    }
+  }
+}
+
+void usemtl_cb(void *user_data, const char *name, int material_idx) {
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+  if ((material_idx > -1) && (material_idx < mesh->materials.size())) {
+    printf("usemtl. material id = %d(name = %s)\n", material_idx,
+           mesh->materials[material_idx].name.c_str());
+  } else {
+    printf("usemtl. name = %s\n", name);
+  }
+}
+
+void mtllib_cb(void *user_data, const tinyobj::material_t *materials,
+               int num_materials) {
+  MyMesh *mesh = reinterpret_cast<MyMesh *>(user_data);
+  printf("mtllib. # of materials = %d\n", num_materials);
+
+  for (int i = 0; i < num_materials; i++) {
+    mesh->materials.push_back(materials[i]);
+  }
+}
+
+void group_cb(void *user_data, const char **names, int num_names) {
+  // MyMesh *mesh = reinterpret_cast<MyMesh*>(user_data);
+  printf("group : name = \n");
+
+  for (int i = 0; i < num_names; i++) {
+    printf("  %s\n", names[i]);
+  }
+}
+
+void object_cb(void *user_data, const char *name) {
+  // MyMesh *mesh = reinterpret_cast<MyMesh*>(user_data);
+  printf("object : name = %s\n", name);
+}
+
+int main(int argc, char **argv) {
+  tinyobj::callback_t cb;
+  cb.vertex_cb = vertex_cb;
+  cb.normal_cb = normal_cb;
+  cb.texcoord_cb = texcoord_cb;
+  cb.index_cb = index_cb;
+  cb.usemtl_cb = usemtl_cb;
+  cb.mtllib_cb = mtllib_cb;
+  cb.group_cb = group_cb;
+  cb.object_cb = object_cb;
+
+  MyMesh mesh;
+  std::string err;
+  std::string filename = "../../models/cornell_box.obj";
+  if (argc > 1) {
+    filename = std::string(argv[1]);
+  }
+  std::ifstream ifs(filename.c_str());
+
+  if (ifs.fail()) {
+    std::cerr << "file not found." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  tinyobj::MaterialFileReader mtlReader("../../models/");
+
+  bool ret = tinyobj::LoadObjWithCallback(ifs, cb, &mesh, &mtlReader, &err);
+
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+
+  if (!ret) {
+    std::cerr << "Failed to parse .obj" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  printf("# of vertices         = %ld\n", mesh.vertices.size() / 3);
+  printf("# of normals          = %ld\n", mesh.normals.size() / 3);
+  printf("# of texcoords        = %ld\n", mesh.texcoords.size() / 2);
+  printf("# of vertex indices   = %ld\n", mesh.v_indices.size());
+  printf("# of normal indices   = %ld\n", mesh.vn_indices.size());
+  printf("# of texcoord indices   = %ld\n", mesh.vt_indices.size());
+  printf("# of materials = %ld\n", mesh.materials.size());
+
+  return EXIT_SUCCESS;
+}

data/ext/pixo/ext/tinyobjloader/examples/obj_sticher/obj_sticher.cc

@@ -0,0 +1,110 @@
+//
+// Stiches multiple .obj files into one .obj. 
+//
+#include "../../tiny_obj_loader.h"
+#include "obj_writer.h"
+
+#include <cassert>
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+
+typedef std::vector<tinyobj::shape_t> Shape;
+typedef std::vector<tinyobj::material_t> Material;
+
+void
+StichObjs(
+  std::vector<tinyobj::shape_t>& out_shape,
+  std::vector<tinyobj::material_t>& out_material,
+  const std::vector<Shape>& shapes,
+  const std::vector<Material>& materials)
+{
+  int numShapes = 0;
+  for (size_t i = 0; i < shapes.size(); i++) {
+    numShapes += (int)shapes[i].size();
+  }
+
+  printf("Total # of shapes = %d\n", numShapes);
+  int materialIdOffset = 0;
+
+  size_t face_offset = 0;
+  for (size_t i = 0; i < shapes.size(); i++) {
+
+    for (size_t k = 0; k < shapes[i].size(); k++) {
+
+      std::string new_name = shapes[i][k].name;
+      // Add suffix
+      char buf[1024];
+      sprintf(buf, "_%04d", (int)i);
+      new_name += std::string(buf);
+
+      printf("shape[%ld][%ld].name = %s\n", i, k, shapes[i][k].name.c_str());
+      assert((shapes[i][k].mesh.indices.size() % 3) == 0);
+      assert((shapes[i][k].mesh.positions.size() % 3) == 0);
+
+      tinyobj::shape_t new_shape = shapes[i][k];
+      // Add offset.
+      for (size_t f = 0; f < new_shape.mesh.material_ids.size(); f++) {
+        new_shape.mesh.material_ids[f] += materialIdOffset;
+      }
+
+      new_shape.name = new_name;
+      printf("shape[%ld][%ld].new_name = %s\n", i, k, new_shape.name.c_str());
+
+      out_shape.push_back(new_shape);
+    }
+
+    materialIdOffset += materials[i].size();
+  }
+
+  for (size_t i = 0; i < materials.size(); i++) {
+    for (size_t k = 0; k < materials[i].size(); k++) {
+      out_material.push_back(materials[i][k]);
+    }
+  }
+
+}
+
+int
+main(
+  int argc,
+  char **argv)
+{
+  if (argc < 3) {
+    printf("Usage: obj_sticher input0.obj input1.obj ... output.obj\n");
+    exit(1);
+  }
+
+  int num_objfiles = argc - 2;
+  std::string out_filename = std::string(argv[argc-1]); // last element
+
+  std::vector<Shape> shapes;
+  std::vector<Material> materials;
+  shapes.resize(num_objfiles);
+  materials.resize(num_objfiles);
+
+  for (int i = 0; i < num_objfiles; i++) {
+    std::cout << "Loading " << argv[i+1] << " ... " << std::flush;
+    
+    std::string err;
+    bool ret = tinyobj::LoadObj(shapes[i], materials[i], err, argv[i+1]);
+    if (!err.empty()) {
+      std::cerr << err << std::endl;
+    }
+    if (!ret) {
+      exit(1);
+    }
+
+    std::cout << "DONE." << std::endl;
+  }
+
+  std::vector<tinyobj::shape_t> out_shape;
+  std::vector<tinyobj::material_t> out_material;
+  StichObjs(out_shape, out_material, shapes, materials);
+
+  bool coordTransform = true;
+  bool ret = WriteObj(out_filename, out_shape, out_material, coordTransform);
+  assert(ret);
+
+  return 0;
+}

data/ext/pixo/ext/tinyobjloader/examples/obj_sticher/obj_writer.cc

@@ -0,0 +1,176 @@
+//
+// Simple wavefront .obj writer
+//
+#include "obj_writer.h"
+#include <cstdio>
+
+static std::string GetFileBasename(const std::string& FileName)
+{
+    if(FileName.find_last_of(".") != std::string::npos)
+        return FileName.substr(0, FileName.find_last_of("."));
+    return "";
+}
+
+bool WriteMat(const std::string& filename, const std::vector<tinyobj::material_t>& materials) {
+  FILE* fp = fopen(filename.c_str(), "w");
+  if (!fp) {
+    fprintf(stderr, "Failed to open file [ %s ] for write.\n", filename.c_str());
+    return false;
+  }
+
+  for (size_t i = 0; i < materials.size(); i++) {
+
+    tinyobj::material_t mat = materials[i];
+
+    fprintf(fp, "newmtl %s\n", mat.name.c_str());
+    fprintf(fp, "Ka %f %f %f\n", mat.ambient[0], mat.ambient[1], mat.ambient[2]);
+    fprintf(fp, "Kd %f %f %f\n", mat.diffuse[0], mat.diffuse[1], mat.diffuse[2]);
+    fprintf(fp, "Ks %f %f %f\n", mat.specular[0], mat.specular[1], mat.specular[2]);
+    fprintf(fp, "Kt %f %f %f\n", mat.transmittance[0], mat.specular[1], mat.specular[2]);
+    fprintf(fp, "Ke %f %f %f\n", mat.emission[0], mat.emission[1], mat.emission[2]);
+    fprintf(fp, "Ns %f\n", mat.shininess);
+    fprintf(fp, "Ni %f\n", mat.ior);
+    // @todo { texture }
+  }
+  
+  fclose(fp);
+
+  return true;
+}
+
+bool WriteObj(const std::string& filename, const std::vector<tinyobj::shape_t>& shapes, const std::vector<tinyobj::material_t>& materials, bool coordTransform) {
+  FILE* fp = fopen(filename.c_str(), "w");
+  if (!fp) {
+    fprintf(stderr, "Failed to open file [ %s ] for write.\n", filename.c_str());
+    return false;
+  }
+
+  std::string basename = GetFileBasename(filename);
+  std::string material_filename = basename + ".mtl";
+
+  int v_offset = 0;
+  int vn_offset = 0;
+  int vt_offset = 0;
+  int prev_material_id = -1;
+
+  fprintf(fp, "mtllib %s\n", material_filename.c_str());
+
+  for (size_t i = 0; i < shapes.size(); i++) {
+
+    bool has_vn = false;
+    bool has_vt = false;
+
+    if (shapes[i].name.empty()) {
+      fprintf(fp, "g Unknown\n");
+    } else {
+      fprintf(fp, "g %s\n", shapes[i].name.c_str());
+    }
+
+    //if (!shapes[i].material.name.empty()) {
+    //  fprintf(fp, "usemtl %s\n", shapes[i].material.name.c_str());
+    //}
+
+    // facevarying vtx
+    for (size_t k = 0; k < shapes[i].mesh.indices.size() / 3; k++) {
+      for (int j = 0; j < 3; j++) {
+        int idx = shapes[i].mesh.indices[3*k+j];
+        if (coordTransform) {
+          fprintf(fp, "v %f %f %f\n",
+            shapes[i].mesh.positions[3*idx+0],
+            shapes[i].mesh.positions[3*idx+2],
+            -shapes[i].mesh.positions[3*idx+1]);
+        } else {
+          fprintf(fp, "v %f %f %f\n",
+            shapes[i].mesh.positions[3*idx+0],
+            shapes[i].mesh.positions[3*idx+1],
+            shapes[i].mesh.positions[3*idx+2]);
+        }
+      }
+    }
+
+    // facevarying normal
+    if (shapes[i].mesh.normals.size() > 0) {
+      for (size_t k = 0; k < shapes[i].mesh.indices.size() / 3; k++) {
+        for (int j = 0; j < 3; j++) {
+          int idx = shapes[i].mesh.indices[3*k+j];
+          if (coordTransform) {
+            fprintf(fp, "vn %f %f %f\n",
+              shapes[i].mesh.normals[3*idx+0],
+              shapes[i].mesh.normals[3*idx+2],
+              -shapes[i].mesh.normals[3*idx+1]);
+          } else {
+            fprintf(fp, "vn %f %f %f\n",
+              shapes[i].mesh.normals[3*idx+0],
+              shapes[i].mesh.normals[3*idx+1],
+              shapes[i].mesh.normals[3*idx+2]);
+          }
+        }
+      }
+    }
+    if (shapes[i].mesh.normals.size() > 0) has_vn = true;
+
+    // facevarying texcoord
+    if (shapes[i].mesh.texcoords.size() > 0) {
+      for (size_t k = 0; k < shapes[i].mesh.indices.size() / 3; k++) {
+        for (int j = 0; j < 3; j++) {
+          int idx = shapes[i].mesh.indices[3*k+j];
+          fprintf(fp, "vt %f %f\n",
+            shapes[i].mesh.texcoords[2*idx+0],
+            shapes[i].mesh.texcoords[2*idx+1]);
+        }
+      }
+    }
+    if (shapes[i].mesh.texcoords.size() > 0) has_vt = true;
+
+    // face
+    for (size_t k = 0; k < shapes[i].mesh.indices.size() / 3; k++) {
+  
+      // Face index is 1-base.
+      //int v0 = shapes[i].mesh.indices[3*k+0] + 1 + v_offset;
+      //int v1 = shapes[i].mesh.indices[3*k+1] + 1 + v_offset;
+      //int v2 = shapes[i].mesh.indices[3*k+2] + 1 + v_offset;
+      int v0 = (3*k + 0) + 1 + v_offset;
+      int v1 = (3*k + 1) + 1 + v_offset;
+      int v2 = (3*k + 2) + 1 + v_offset;
+
+      int vt0 = (3*k + 0) + 1 + vt_offset;
+      int vt1 = (3*k + 1) + 1 + vt_offset;
+      int vt2 = (3*k + 2) + 1 + vt_offset;
+
+      int material_id = shapes[i].mesh.material_ids[k];
+      if (material_id != prev_material_id) {
+        std::string material_name = materials[material_id].name;
+        fprintf(fp, "usemtl %s\n", material_name.c_str());
+        prev_material_id = material_id;
+      }
+
+      if (has_vn && has_vt) {
+        fprintf(fp, "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
+          v0, vt0, v0, v1, vt1, v1, v2, vt2, v2);
+      } else if (has_vn && !has_vt) {
+        fprintf(fp, "f %d//%d %d//%d %d//%d\n", v0, v0, v1, v1, v2, v2);
+      } else if (!has_vn && has_vt) {
+        fprintf(fp, "f %d/%d %d/%d %d/%d\n", v0, v0, v1, v1, v2, v2);
+      } else {
+        fprintf(fp, "f %d %d %d\n", v0, v1, v2);
+      }
+      
+    }
+
+    v_offset  += shapes[i].mesh.indices.size();
+    //vn_offset += shapes[i].mesh.normals.size() / 3;
+    vt_offset += shapes[i].mesh.texcoords.size() / 2;
+
+  }
+
+  fclose(fp);
+
+  //
+  // Write material file
+  //
+  bool ret = WriteMat(material_filename, materials);
+
+  return ret;
+}
+
+

data/ext/pixo/ext/tinyobjloader/examples/obj_sticher/obj_writer.h

@@ -0,0 +1,9 @@
+#ifndef __OBJ_WRITER_H__
+#define __OBJ_WRITER_H__
+
+#include "../../tiny_obj_loader.h"
+
+extern bool WriteObj(const std::string& filename, const std::vector<tinyobj::shape_t>& shapes, const std::vector<tinyobj::material_t>& materials, bool coordTransform = false);
+
+
+#endif // __OBJ_WRITER_H__

data/ext/pixo/ext/tinyobjloader/examples/obj_sticher/premake4.lua

@@ -0,0 +1,38 @@
+lib_sources = {
+   "../../tiny_obj_loader.cc"
+}
+
+sources = {
+   "obj_sticher.cc",
+   "obj_writer.cc",
+   }
+
+-- premake4.lua
+solution "ObjStickerSolution"
+   configurations { "Release", "Debug" }
+
+   if (os.is("windows")) then
+      platforms { "x32", "x64" }
+   else
+      platforms { "native", "x32", "x64" }
+   end
+
+   includedirs {
+      "../../"
+   }
+
+   -- A project defines one build target
+   project "obj_sticher"
+      kind "ConsoleApp"
+      language "C++"
+      files { lib_sources, sources }
+
+      configuration "Debug"
+         defines { "DEBUG" } -- -DDEBUG
+         flags { "Symbols" }
+         targetname "obj_sticher_debug"
+
+      configuration "Release"
+         -- defines { "NDEBUG" } -- -NDEBUG
+         flags { "Symbols", "Optimize" }
+         targetname "obj_sticher"

data/ext/pixo/ext/tinyobjloader/examples/viewer/README.md

@@ -0,0 +1,37 @@
+# Simple .obj viewer with glew + glfw3 + OpenGL
+
+## Requirements
+
+* premake5
+* glfw3
+* glew
+
+
+## Build on MaCOSX
+
+Install glfw3 and glew using brew.
+Then,
+
+    $ premake5 gmake
+    $ make
+
+## Build on Linux
+
+Set `PKG_CONFIG_PATH` or Edit path to glfw3 and glew in `premake4.lua`
+
+Then,
+
+    $ premake5 gmake
+    $ make
+
+## Build on Windows.
+
+* Visual Studio 2013
+* Windows 64bit
+  * 32bit may work.
+
+Put glfw3 and glew library somewhere and replace include and lib path in `premake4.lua`
+
+Then,
+
+    > premake5.exe vs2013

data/ext/pixo/ext/tinyobjloader/examples/viewer/premake4.lua

@@ -0,0 +1,44 @@
+solution "objview"
+	-- location ( "build" )
+	configurations { "Release", "Debug" }
+	platforms {"native", "x64", "x32"}
+	
+	project "objview"
+
+		kind "ConsoleApp"
+		language "C++"
+		files { "viewer.cc", "trackball.cc" }
+		includedirs { "./" }
+		includedirs { "../../" }
+
+		configuration { "linux" }
+			linkoptions { "`pkg-config --libs glfw3`" }
+			links { "GL", "GLU", "m", "GLEW", "X11", "Xrandr", "Xinerama", "Xi", "Xxf86vm", "Xcursor", "dl" }
+			linkoptions { "-pthread" }
+
+		configuration { "windows" }
+			-- Path to GLFW3
+			includedirs { '../../../../local/glfw-3.1.2.bin.WIN64/include' }
+			libdirs { '../../../../local/glfw-3.1.2.bin.WIN64/lib-vc2013' }
+			-- Path to GLEW
+			includedirs { '../../../../local/glew-1.13.0/include' }
+			libdirs { '../../../../local/glew-1.13.0/lib/Release/x64' }
+
+			links { "glfw3", "glew32", "gdi32", "winmm", "user32", "glu32","opengl32", "kernel32" }
+			defines { "_CRT_SECURE_NO_WARNINGS" }
+
+		configuration { "macosx" }
+			includedirs { "/usr/local/include" }
+			buildoptions { "-Wno-deprecated-declarations" }
+			libdirs { "/usr/local/lib" }
+			links { "glfw3", "GLEW" }
+			linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" }
+
+		configuration "Debug"
+			defines { "DEBUG" }
+			flags { "Symbols", "ExtraWarnings"}
+
+		configuration "Release"
+			defines { "NDEBUG" }
+			flags { "Optimize", "ExtraWarnings"}
+